美文网首页
python基础(二)

python基础(二)

作者: pigdaqiang | 来源:发表于2020-01-28 22:53 被阅读0次

python变量赋值
常量 不变化的量,比如数字,字符串都是
变量 存储常量,通常由变量名指出
赋值 就是将一个常量指向一个变量
name = 'while'
python是一门弱变量的语言,所用变量即用即生成,变量的类型随着值的类型的修改而修改
命名可用的内容
字母
数字
下划线

1. 数字不可以开头,也不可以纯数字
2. __开头代表私有
3. __name__代表魔术方法
4. 关键字不可以用于命名
>>>import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 
'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
5. 命名要有意义,禁止无意义的命名,比如,a,a1,bb
常见的命名
名词
    name = 1
动宾结构
    get page = 1
    getPage = 1
    GetPage = 1
变量赋值的三种方式:
传统赋值
    name = 'while'
链式赋值
    name = user = 'while'
序列解包赋值
    name,age = 'while',10
>>> name = 'while'
>>> name
'while'
>>> name = user = 'while'
>>> name,user
('while', 'while')
>>> name,age = 'shuai',18
>>> name,age
('shuai', 18)
>>> hello       变量不存在
Traceback (most recent call last):
 File "<pyshell#14>", line 1, in <module>
 hello
NameError: name 'hello' is not defined
>>> name,age = 'shuai',18,00        变量和常量不对应
Traceback (most recent call last):
 File "<pyshell#15>", line 1, in <module>
   name,age = 'shuai',18,00
ValueError: too many values to unpack (expected 2)

python列表
列表是一个元素以逗号分割,以中括号包围的,有序的,可修改的序列
python2
1、list
2、[]
3、range
4、xrange
python3
1、list
>>> list('abced')
['a', 'b', 'c', 'e', 'd']
>>> str(['a','b','c','d'])
"['a', 'b', 'c', 'd']"
>>> ''.join(['a','b','c'])
'abc'
2、[]
>>> ['a',1,[1,'a']]
['a', 1, [1, 'a']]
3、range
>>> range(100)
range(0, 100)
>>> list(range(100))
[0, 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, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> print(range(100))
range(0, 100)
列表的索引
列表的索引和字符串的索引类似,但不完全相同,因为列表可以修改,所以我们可以通过列表
的索引来修改列表
一样的部分

>>> mylist = [1,2,3,45,6]
>>> mylist
[1, 2, 3, 45, 6]
>>> mylist1 = list('123456')
>>> mylist1
['1', '2', '3', '4', '5', '6']
>>> mylist[1]
2
>>> mylist[-1]
6
>>> mylist[:]
[1, 2, 3, 45, 6]
>>> mylist1[::2]
['1', '3', '5']
>>> mylist1[5:1:-1]
['6', '5', '4', '3']
>>> mylist1[1] = 's'
>>> mylist1
['1', 's', '3', '4', '5', '6']
超出索引范围
    >>> mylist1[100]
    Traceback (most recent call last):
      File "<pyshell#38>", line 1, in <module>
        mylist1[100]
    IndexError: list index out of range

列表的方法
    
    列表的添加   
        append  追加,在列表的尾部加入指定的元素
        extend  将指定序列的元素依次追加到列表的尾部
        insert  将指定的元素插入到对应的索引位上,注意负索引
    列表的删除   
        pop 弹出,返回并删除指定索引位上的数据,默认-1
        remove  从左往右删除一个指定的元素
        del 删除是python内置功能,不是列表独有的
    列表的查找
    注 列表没有find方法    
        count   计数,返回要计数的元素在列表当中的个数
        index   
        查找,从左往右返回查找到的第一个指定元素的索引,如果没有找到,报错
    列表的排序   
        reverse 索引顺序倒序
        sort    按照ascii码表顺序进行排序

    append      列表末尾添加
>>> mylist = list('1a23456')
>>> mylist
['1', 'a', '2', '3', '4', '5', '6']
>>> mylist.append('a')
>>> mylist
['1', 'a', '2', '3', '4', '5', '6', 'a']
>>> mylist.append([123])
>>> mylist
['1', 'a', '2', '3', '4', '5', '6', 'a', [123]]
>>> mylist.append('[123]')
>>> mylist
['1', 'a', '2', '3', '4', '5', '6', 'a', [123], '[123]']
extend      将序列直接添加到末尾
>>> mylist = list('123456')
>>> mylist
['1', '2', '3', '4', '5', '6']
>>> mylist.extend('123')
>>> mylist
['1', '2', '3', '4', '5', '6', '1', '2', '3']

insert      将元素直接添加到指定位置
>>> mylist.insert('a',0)    注意顺序
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    mylist.insert('a',0)
TypeError: 'str' object cannot be interpreted as an integer
>>> mylist.insert(0,'a')
    pop  默认弹出最后一个位置,可以指定弹出的元素
        >>> mylist
        ['a', '1', '2', '3', '4', '5', '6', '1', '2', '3']
        >>> mylist.pop()
        '3'
        >>> mylist
        ['a', '1', '2', '3', '4', '5', '6', '1', '2']
        >>> mylist.pop()
        '2'
        >>> mylist
        ['a', '1', '2', '3', '4', '5', '6', '1']
        >>> list(mylist)
        ['a', '1', '2', '3', '4', '5', '6', '1']
        >>> mylist.pop(0)   弹出指定位置的元素
        'a'

    remove  从左往右删除指定的元素,一次删除一个
        >>> mylist
        ['1', '2', '3', '4', '5', '6', '1']
        >>> mylist.remove(1)
        Traceback (most recent call last):
          File "<pyshell#63>", line 1, in <module>
            mylist.remove(1)
        ValueError: list.remove(x): x not in list
        >>> mylist.remove('1')
        >>> mylist
        ['2', '3', '4', '5', '6', '1']

    del     删除指定位置的元素
        >>> del mylist[1]
        >>> mylist
        ['2', '4', '5', '6', '1']
        >>> del mylist[0]
        >>> mylist
        ['4', '5', '6', '1']
        >>> del mylist('1')
        SyntaxError: can't delete function call
        >>> del mylist
        >>> mylist
        Traceback (most recent call last):
          File "<pyshell#72>", line 1, in <module>
            mylist
        NameError: name 'mylist' is not defined
    
    count   寻找指定元素的个数  #注意list方法和[]这个的区别
     一个是字符串一个是数字 使用函数的方法也不一样
        >>> mylist = list('12345')
        >>> mylist
        ['1', '2', '3', '4', '5']
        >>> mylist.count(0)
        0
        >>> mylist.count(1)
        0
        >>> mylist.count(2)
        0
        >>> mylist = list('1234566')
        >>> mylist
        ['1', '2', '3', '4', '5', '6', '6']
        >>> mylist.count(6)
        0
        >>> mylist.count('6')
        2
        >>> mylist = [1,2,3,4]
        >>> mylist.count(1)
        1
        >>> mylist
        [1, 2, 3, 4]
    
    index   从左往右寻找指定元素的索引,第一个元素
        >>> mylist
        [1, 2, 3, 4]
        >>> mylist.index(1)
        0
        >>> mylist.index(2)
        1
        >>> mylist.index(3)
        2
        >>> mylist = list('1234')
        >>> mylist.index('1')
        0
        >>> mylist.index(1)
        Traceback (most recent call last):
          File "<pyshell#93>", line 1, in <module>
            mylist.index(1)
        ValueError: 1 is not in list
    
    reverse     按照索引顺序进行倒序
        >>> mylist
        ['1', '2', '3', '4']
        >>> mylist.reverse()
        >>> mylist
        ['4', '3', '2', '1']
        >>> mylist = list('dadgasgreaghfdah')
        >>> mylist
        ['d', 'a', 'd', 'g', 'a', 's', 'g', 'r', 'e', 'a', 'g', 'h', 'f', 
        'd', 'a', 'h']
        >>> mylist.reverse()
        >>> mylist
        ['h', 'a', 'd', 'f', 'h', 'g', 'a', 'e', 'r', 'g', 's', 'a', 'g', 
        'd', 'a', 'd']

    sort    直接按照ascii码排序,不能数字和字符一起排序
        >>> mylist
        ['h', 'a', 'd', 'f', 'h', 'g', 'a', 'e', 'r', 'g', 's', 'a', 'g', 'd', 'a', 'd']
        >>> mylist.sort()        
        >>> mylist
        ['a', 'a', 'a', 'a', 'd', 'd', 'd', 'e', 'f', 'g', 'g', 'g', 'h', 'h', 'r', 's']
        >>> mylist = [1,2,3,4]
        >>> mylist.sort()
        >>> mylist
        [1, 2, 3, 4]
        >>> mylist = [1,'a',2,3]
        >>> mylist
        [1, 'a', 2, 3]
        >>> mylist.sort()
        Traceback (most recent call last):
          File "<pyshell#109>", line 1, in <module>
            mylist.sort()
        TypeError: '<' not supported between instances of 'str' and 'int'
        >>> mylist = [1,2,3,'1']
        >>> mylist.sort()
        Traceback (most recent call last):
          File "<pyshell#111>", line 1, in <module>
            mylist.sort()
        TypeError: '<' not supported between instances of 'str' and 'int'

python元组
元组是元素以逗号分割,以小括号包围的有序的,不可修改的序列
tuple()
构建元组的方法

    >>> mytuple = tuple('12345')
    >>> mytuple
    ('1', '2', '3', '4', '5')
    
    >>> ('a',1,3)
    ('a', 1, 3)
元组的索引和字符串是一样的
    >>> mytuple
    ('1', '2', '3', '4', '5')
    >>> mytuple.count('1')
    1
    >>> mytuple.count(2)
    0
    >>> mytuple.count('2')
    1
    >>> mytuple.count('1')
    1
    >>> mytuple.count('3')
    1
    >>> mytuple[::-1]
    ('5', '4', '3', '2', '1')
    >>> mytuple[-1]
    '5'
    >>> mytuple
    ('1', '2', '3', '4', '5')
    >>> mytuple[1]
    '2'
    >>> mytuple[0:3]
    ('1', '2', '3')
    >>> mytuple[5:0:-1]
    ('5', '4', '3', '2')
    >>> mytuple[5::-1]
    ('5', '4', '3', '2', '1')
元组的特性
    元组可以不加括号
        >>> 1,2
        (1, 2)
    单元素元组需要加逗号
        >>> type([1])
        <class 'list'>
        >>> type((1))
        <class 'int'>
        >>> type((21,))
        <class 'tuple'>
    元组不可修改,所以我们再配置文件中多看到元组
        Django 配置的一部分
        DATABASE = (
        Os.path.join(BASEDIR," TEMPLATE"),
        )
元组的方法
    元组的查找
        index   从左往右指定元素的索引,遇见的第一个元素
        count   寻找元组中的指定的元素的个数
            >>> mytuple
            ('1', '2', '3', '4', '5')
            >>> mytuple.index('1')
            0
            >>> mytuple.index('5')
            4
            >>> mytuple.count('1')
            1
            >>> mytuple.count('5')
            1

元组和字符串的区别
1、元组和字符串都是有序的,不可修改的序列
2、元组的元素可以是任何类型,字符串的元素只能是字符
3、元组的元素长度可以任意,字符串的元素长度只能为 1
验证元组和字符串的长度
>>> a
'abc'
>>> mytuple
'shuai'
>>> len(a[0])
1
>>> len(mytuple[0])
1
>>> mytuple = ('shuai',1)
>>> mytuple
('shuai', 1)
>>> len(mytuple[0])
5
元组的创建方法
>>> a
'shuai'
>>> mytuple = ('shuai',a)
>>> mytuple
('shuai', 'shuai')

>>> mytuple = ('shuai',1)
>>> mytuple
('shuai', 1)
>>> len(mytuple[0])
5

>>> mytuple = ('shuai',a)   a = 'shuai'
>>> mytuple
('shuai', 'shuai')
>>> len(mytuple[0])
5

>>> mytuple = ('shuai',b)   引入字符串必须放在引号里
Traceback (most recent call last):
  File "<pyshell#196>", line 1, in <module>
    mytuple = ('shuai',b)
NameError: name 'b' is not defined
>>> mytuple = ('shuai','b')
>>> mytuple
('shuai', 'b')

>>> mytuple = ('shuai',1) 数字可以放在外面
>>> mytuple
('shuai', 1)

>>> mytuple = ('shuai',)
>>> mytuple
('shuai',)
>>> len(mytuple[0])
5

>>> mytuple = ('shuai,shuai')  与这个区分,这是字符串的创建方法

python字典
字典一个元素呈键值对的形式,以逗号分割,以大括号包围的无序的,可以修改的序列。
字典是python基础数据类型当中唯一一个映射关系的数据类型,通常对应JSON{}
字典创建方法
>>> mydict = {'a':1,"b":2}
>>> mydict
{'a': 1, 'b': 2}
fromkeys 这种方法只能给所有的键都赋一样的值
>>> mydict = {}.fromkeys('abcd')
>>> mydict
{'a': None, 'b': None, 'c': None, 'd': None}
>>> mydict = {}.fromkeys('abcd','shuai')
>>> mydict
{'a': 'shuai', 'b': 'shuai', 'c': 'shuai', 'd': 'shuai'}

dict
    zip 
    函数:将几个序列对应索引位上的元素分到一个元组中,总的形成一个列表,子元组的
    个数取决于提供的序列的最小长度
python2 与python3的区别
    python2 直接返回对象
    python3 返回对象的内存地址,需要用列表进行转换
    补充:python3中减少了内存的占用,优化了性能但是速度更慢了

        >>> myzip = zip('abcd','1234')
        >>> myzip
        <zip object at 0x00000223D8276BC8>      python3中的内存地址
        >>> list(myzip)                         
                                    元素啄一对应,长度取决于最小的序列的长度
        [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
        >>> myzip = zip('abcd','123456','shuai','1234')
        >>> myzip
        <zip object at 0x00000223D828A388>
        >>> list(myzip)
        [('a', '1', 's', '1'), ('b', '2', 'h', '2'), ('c', '3', 'u', 
        '3'), ('d', '4', 'a', '4')]
        
        >>> dict([('a',1),('b',2)])
        {'a': 1, 'b': 2}
        >>> dict(zip('abcdefg','1234567'))
        {'a': '1', 'b': '2', 'c': '3', 'd': '4', 'e': '5', 'f': '6', 'g': '7'}
        >>> mydict = zip('abcd','1234')
        >>> mydict
        <zip object at 0x00000223D828AE08>
        >>> list(mydict)
        [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
        >>> mydict = dict(mydict)
        >>> mydict
        {}
        
        >>> mydict = zip('abcd','1234')
        >>> mydict = dict(mydict)
        >>> mydict
        {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
        >>> mydict = zip('abcd','1234')
        >>> mydict
        <zip object at 0x0000018304BCF2C8>

        >>> list(mydict)
        [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
        >>> dict(mydict)
        {}
        >>> mydict = zip('abcd','1234')
        >>> dict(mydict)
        {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
    mydict = zip('')    创建的是列表
    dict(zip())     列表转为字典
    dict([()])      元组-->列表-->字典

    字典的特点:
        因为字典是无序的,所以字典没有索引值
        因为字典没有索引值,所以字典以键取值,(字典的键相当于列表的索引)
            >>> myzip = dict(zip('abcd','1234'))
            >>> myzip
            {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
            >>> myzip['a']
            '1'
    因为字典以键取值,所以字典的键唯一且不可修改。
    因为字典的键不可修改,所以列表和字典不可以给字典做键。
            >>> myzip = {'a':1,1:'a',(1,2):'c'}
            >>> myzip
            {'a': 1, 1: 'a', (1, 2): 'c'}
            >>> myzip = {'a':1,1:'a',(1,2):'c',{'a':1}:1}
            Traceback (most recent call last):
              File "<pyshell#48>", line 1, in <module>
                myzip = {'a':1,1:'a',(1,2):'c',{'a':1}:1}
            TypeError: unhashable type: 'dict'
        字典和列表不可以作为字典的键
字典的方法:
    字典的取值:
        keys        获取字典所有的键
        values      获取字典所有的值
        get         以键取值,如果指定键不存在,默认返回None可以指定返回内容
        update      更新指定键的内容,如果键不存在就直接创建
        setdefault  设置默认,如果键存在,返回值,如果键不存在,创造键,值默认
                    为None,值也可以自定义
        items       返回字典键值呈元组形式的格式
    字典的删除
        pop         弹出,返回并删除指定键对应的值
        popitem     随机弹出一个键值元组,这里随机的原因是因为字典无序
        clear       清空字典
            字典的取值
                >>> mydict = dict(zip('abc','123'))
                >>> mydict
                {'a': '1', 'b': '2', 'c': '3'}
            keys
                >>> mydict.keys()
                dict_keys(['a', 'b', 'c'])
            values
                >>> mydict.values()
                dict_values(['1', '2', '3'])
                >>> list(mydict.keys())
                ['a', 'b', 'c']
                >>> list(mydict.values())
                ['1', '2', '3']
                >>> mydict.get('a')
                '1'
                >>> mydict['a']
                '1'
                >>> mydict.get('x')
                >>> mydict['x']
                Traceback (most recent call last):
                  File "<pyshell#74>", line 1, in <module>
                    mydict['x']
                KeyError: 'x'

            >>> mydict.update(dict(zip('a',1)))
            Traceback (most recent call last):
              File "<pyshell#75>", line 1, in <module>
                mydict.update(dict(zip('a',1)))
            TypeError: zip argument #2 must support iteration
            >>> mydict.update({'a',1})
            Traceback (most recent call last):
              File "<pyshell#76>", line 1, in <module>
                mydict.update({'a',1})
            TypeError: cannot convert dictionary update sequence element #0 to a sequence
                >>> mydict
                {'a': '1', 'b': '2', 'c': '3'}
                >>> mydict.update({'a':1})
                >>> mydict
                {'a': 1, 'b': '2', 'c': '3'}
                >>> mydict.update({'a':2})
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3'}
                >>> mydict+{'y':1}
                Traceback (most recent call last):
                  File "<pyshell#83>", line 1, in <module>
                    mydict+{'y':1}
                TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
                >>> mydict.update({'x':55})
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55}

                >>> mydict.setdefault('x')
                55
                >>> mydict.setdefault('y')
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None}
                >>> mydict.setdefault('y',88)
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None}
                >>> mydict.setdefault('h',99)
                99
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55, 'y': None, 'h': 99}
                >>> mydict.items()
                dict_items([('a', 2), ('b', '2'), ('c', '3'), ('x', 55), 
                ('y', None), ('h', 99)])
                >>> list(mydict.items())
                [('a', 2), ('b', '2'), ('c', '3'), ('x', 55), ('y', 
                None), ('h', 99)]
                >>> 
    字典的删除
        pop     只能弹出指定的内容键,不能弹出数值
                >>> mydict.pop()
                Traceback (most recent call last):
                  File "<pyshell#96>", line 1, in <module>
                    mydict.pop()
                TypeError: pop expected at least 1 arguments, got 0
                >>> mydict.pop('y')
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55, 'h': 99}
                >>> mydict.pop('h')
                99
                >>> mydict
                {'a': 2, 'b': '2', 'c': '3', 'x': 55}
                >>> mydict.pop(55)
                Traceback (most recent call last):
                  File "<pyshell#101>", line 1, in <module>
                    mydict.pop(55)
                KeyError: 55

        popitem clear   随机弹出内容,清空内容
                    >>> mydict
                    {'a': 2, 'b': '2', 'c': '3', 'x': 55}
                    >>> mydict.popitem()
                    ('x', 55)
                    >>> mydict.popitem()
                    ('c', '3')
                    >>> mydict.popitem()
                    ('b', '2')
                    >>> mydict
                    {'a': 2}
                    >>> list(mydict.items())
                    [('a', 2)]
                    >>> mydict = dict(zip('abcd','1234'))
                    >>> mydict
                    {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
                    >>> list(mydict.items())
                    [('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
                    >>> mydict.popitem()
                    ('d', '4')
                    >>> mydict.popitem()
                    ('c', '3')
                    >>> mydict.popitem()
                    ('b', '2')
                    >>> mydict
                    {'a': '1'}
                    >>> mydict.clear()
                    >>> mydict
                    {}
        python2中
            判断has_key
        python3
            用in     替换
            in判定有没有指定的键
                >>> mydict = dict(zip('abcd','1234'))
                >>> mydict
                {'a': '1', 'b': '2', 'c': '3', 'd': '4'}
                >>> 'a' in mydict       判断a 是否在字典里
                True
                >>> 2 in mydict
                False
                >>> '2' in mydict
                False

字典的拷贝属于浅层拷贝,拷贝和拷贝对象的嵌套层同属一个内存,一个修改另一个也会修改
普通键对应的值发生变化,复制的字典值不变,列表对应的键值变了,复制的列表的对应的键值也变化
>>> mydict
{'a': '1', 'b': '2', 'c': '3', 'd': '4'}
>>> mydict.update({'z':[11]})
>>> mydict
{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
>>> mydict_1 = mydict.copy()
>>> mydict_1
{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
>>> mydict['a'] = 11
>>> mydict
{'a': 11, 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
>>> mydict_1
{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [11]}
>>> mydict['z'][0] = 5
>>> mydict
{'a': 11, 'b': '2', 'c': '3', 'd': '4', 'z': [5]}
>>> mydict_1
{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'z': [5]}

数据类型的总结

        str     list    tuple   dict

是否有序 是 是 是 否
是否可修改 不 可 不 可
方法多少 很多 一般 很少 较多 映射关系


相关文章

网友评论

      本文标题:python基础(二)

      本文链接:https://www.haomeiwen.com/subject/tmamthtx.html