zoukankan      html  css  js  c++  java

  • python学习笔记3：基础(元组、字符串、列表、字典)

    参考文档：http://www.cnblogs.com/liu-yao/p/5145876.html
     
    一，对象与类
    对象：
    python中一切皆为对象，所谓对象：我自己就是一个对象，我玩的电脑就是对象，玩的手机就是对象。
    我们通过描述属性（特征）和行为来描述一个对象的。

    在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）

    结论：对象=属性+方法

    在python中，把具有相同属性和方法的对象归为一个类（class）

    比如人类，动物，植物等等，这些都是类的概念。

    类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。

     
    例如：”liuyao“ “yaoyao” “shabi” 都是根据不同的类进行创建的对象
     

    一,整数
    1.int型

    具有的功能：

    1
    class int(object):

    (1).返回表示该数字的时占用的最少位数

    1
    2
    3
    4
    def bit_length(self):
    例:
    >>> bin(10)
    '0b1010' #0b是二进制，1010是所占位数

    (2).返回绝对值

    1
    2
    3
    4
    5
    6
    7
    def __abs__(self):
    例:
    >>> absolute = -10
    >>> absolute.__abs__()
    10
    >>> abs(-10)
    10

    (3).相除，得到商和余数组成的元组

    1
    2
    3
    4
    5
    6
    def __divmod__(self)
    例：
    >>> age = 21
    >>> sb = age.__divmod__(6)
    >>> print (sb)
    (3, 3)

    (4).int转换为浮点类型

    (5).__cmp__(self, y)比较两个数大小   注：在3.x版本被

    (6).__coerce__(self, y)强制生成一个元组   注：在3.x版本被取消

    (7).数值相加

    1
    2
    3
    4
    5
    6
    7
    8
    def __add__(self,other)
    例：
    >>> num1 = 15
    >>> num2 = 20
    >>> print (num1+num2)
    35
    >>> print (num1.__add__(num2))
    35

    (8).布尔值

    1
    2
    3
    4
    5
    6
    >>> bool = 0
    >>> print(bool.__bool__())
    False
    >>> bool = 1
    >>> print(bool.__bool__())
    True

    9. 判断是是否相等

    1
    2
    3
    4
    >>> zhi1=10
    >>> zhi2=11
    >>> print (zhi1.__eq__(zhi2))
    False

    10. 返回浮点

    1
    2
    3
    >>> zhi = 10
    >>> print(zhi.__float__())
    10.0

    11. 地板除

    1
    2
    3
    4
    >>> a=10
    >>> b=3
    >>> print(a.__floordiv__(b))
    3

    12. 大于等于

    1
    2
    3
    4
    >>> a=20
    >>> b=12
    >>> print(a.__ge__(b))
    True

    13. 大于

    1
    2
    >>> print(a.__gt__(b))
    True

    14.哈希

    1
    print(num.__hash__())

    15.__invert__ :取反

    1
    2
    3
    >>> a=45
    >>> print(a.__invert__())
    -46

    16.小于等于

    1
    2
    3
    4
    >>> a=10
    >>> b=20
    >>> print (a.__lt__(b))
    True

    17. __lshift__ :左移位

    1
    2
    3
    4
    >>> num1 = 10
    >>> num2 = 10
    >>> print (num1.__lshift__(num2))
    10240

    18.求模

    1
    2
    3
    4
    >>> a=20
    >>> b=11
    >>> print(a.__mod__(b))
    9

    19.相乘

    1
    2
    3
    4
    >>> a=10
    >>> b=2
    >>> print (a.__mul__(b))
    20

    20.取反

    1
    2
    3
    >>> a=21
    >>> print (a.__neg__())
    -21

    21.不等于

    1
    2
    3
    4
    >>> a=20
    >>> b=10
    >>> print(a.__ne__(b))
    True

    22.取正数

    1
    2
    3
    4
    5
    6
    >>> a=-10
    >>> print(a.__pos__())
    -10
    >>> a=10
    >>> print(a.__pos__())
    10

    23 乘方

    1
    2
    3
    >>> a=10
    >>> print(a.__pow__(10))
    10000000000

    24.右加（以下前缀为r的都是右；前缀为l的都是左）

    1
    print(a.__radd__(b))

    25.右或

    1
    print(a.__repr__())

    26.右除以左，返回商和余数

    1
    print(a.__repr__())

    27.转换为解释器可读取的形式

    1
    print(a.__repr__())

    28.转换为字符串

    1
    2
    3
    >>> a=10
    >>> print(a.__pow__(10))
    10000000000

    29.求差 

    1
    2
    3
    >>>num=10
    >>>num2=20
    print(num.__sub__(num2))

    2、long型

    具有的功能：

    1
    class long(object):

    同int型

    3.float型

    1.返回分子分母数构成的元祖
    1
    as_integer_ratio()

    2.将十六进制数转换为浮点数

    1
    print(float.fromhex('0x1.ffffp10'))

    3.将浮点数转换为十六进制数

    1
    print(2047.984375.hex())

    4.判断浮点数是不是整数

    1
    2
    3
    f1 = 10.2
    f2 = 10.0
    print(f1.is_integer())31print(f2.is_integer())

    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    二.字符串

    具有的功能：

    1
    class str(basestring):

    1.首字母变大写

    1
    2
    3
    4
    5
    def capitalize(self):
    例：
    >>> name = 'yaoyao'
    >>> print (name.capitalize())
    Yaoyao

    2.内容居中

    1
    2
    3
    4
    5
    6
    def center(self, width, fillchar=None): 
    """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
    例：
    >>> name = 'liuyao'
    >>> print (name.center(20,'*'))
    *******liuyao*******

    3.查询个数

    1
    2
    3
    4
    5
    6
    7
    count(self, sub, start=None, end=None)子序列个数 sub：要查询的子序列 start：开始位置 end：结束位置
    例：
    >>> cou = 'asdfghjasdfgjqweryuzxcvbnm'
    >>> print (cou.count('as'))
    2
    >>> print (cou.count('as',1,25))
    1

    4.编码修改

    1
    2
    3
    4
    5
    6
    encode(self, encoding=None, errors=None）编码，针对unicode  encoding='解码的格式'
    例：
    >>> name = '刘耀'
    >>> print (name.encode('gbk'))
    b'xc1xf5xd2xab'
    >>>

    5.endswith

    1
    2
    3
    4
    5
    6
    7
    endswith(self, suffix, start=None, end=None)是否以xxx结尾 suffix：填入结尾的字符串  start=在第几个字符开始  end=在第几个字符结束
    endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
    例：
    >>> name='asdfghjklo'
    >>> print (name.endswith('lo',0,6))
    False
    >>>

    6.expandtabs()

    1
    2
    3
    4
    5
    expandtabs() 方法把字符串中的 tab 符号(' ')转为空格，默认的空格数 tabsize 是 8
    例：
    >>> extab = 'one two'
    >>> print (extab.expandtabs())
    one     two

    7.find

    1
    2
    3
    4
    5
    6
    7
    find(self, sub, start=None, end=None)寻找子序列位置，如果没找到，返回 -1
    例：
    >>> name = 'yaotwosiji'
    >>> print (name.find('two',1,8))
    3
    >>> print (name.find('two',1,3))
    -1

    8.casefold

    1
    2
    casefold(self)大写转小写 注：3.x新增方法，2.x没有
    例：

    9.format格式化

    1
    2
    3
    4
    5
    6
    format(*args, **kwargs)字符串格式化
    例:
    >>> name = 'liuyao'
    >>> age = '21'
    >>> print ('姓名{0},年龄{1}'.format(name,age))
    姓名liuyao,年龄21

    10.index

    1
    2
    3
    4
    5
    6
    7
    8
    9
    index(self, sub, start=None, end=None)子序列位置，如果没找到，报错
    例：
    >>> name = 'asdfghjklqwertyui'
    >>> print (name.index('fg'))
    3
    >>> print (name.index('fg',1,3))
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: substring not found

    11.isalnum

    1
    2
    3
    4
    5
    6
    7
    8
    isalnum(self)如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
    例：
    >>> zifu = 'yao1995'
    >>> print (zifu.isalnum())
    True
    >>> zifutab = 'yao 1995'
    >>> print (zifutab.isalnum())
    False

    12.isalpha

    1
    2
    3
    4
    5
    isalpha(self)如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
    例：
    >>> zifutab = 'yao'
    >>> print (zifutab.isalpha())
    True

    13.isdigit

    1
    2
    3
    4
    5
    isdigit(self)如果字符串只包含数字则返回 True 否则返回 False
    例：
    >>> shuzi = '1995'
    >>> print (shuzi.isdigit())
    True

    14.islower

    1
    2
    3
    4
    5
    islower(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
    例：
    >>> zifu = 'Liuyao'
    >>> print (zifu.islower())
    False

    15.isspace

    1
    2
    3
    4
    5
    isspace(self)如果字符串中只包含空格，则返回 True，否则返回 False
    例：
    >>> kongge = '    '
    >>> print(kongge.isspace())
    True

    16.istitle

    1
    2
    3
    4
    5
    istitle(self)如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False
    例：
    >>> zifu = 'Liu Yao'
    >>> print (zifu.istitle())
    True

    17.isupper

    1
    2
    3
    4
    5
    isupper(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
    例：
    >>> zifu = 'LIU YAO'
    >>> print (zifu.isupper())
    True

    18.join

    1
    2
    3
    4
    5
    6
    join(self, iterable)返回通过指定字符连接序列中元素后生成的新字符串
    例：
    >>> lj = '^'
    >>> name =('y','a','o')
    >>> print (lj.join(name))
    y^a^o

    19.ljust

    1
    2
    ljust(self, width, fillchar=None)返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
    例：

    20.lower

    1
    2
    3
    4
    lower(self)返回将字符串中所有大写字符转换为小写后生成的字符串
    >>> name = 'LIUYAO'
    >>> print (name.lower())
    liuyao

    21.lstrip

    1
    2
    3
    4
    lstrip(self, chars=None)返回截掉字符串左边的空格或指定字符后生成的新字符串
    >>> name = 'liuyaoliuyaoliuyao'
    >>> print (name.lstrip('liu'))
    yaoliuyaoliuyao

    22.partition

    1
    2
    3
    4
    partition(self, sep)返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
    >>> who = 'wo shi liuyao'
    >>> print (who.partition('shi'))
    ('wo ', 'shi', ' liuyao')

    23.replace

    1
    2
    3
    4
    5
    6
    replace(self, old, new, count=None)返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次
    >>> str1 = 'ni shi wo shi shei shi'
    >>> print (str1.replace('shi','ta'))
    ni ta wo ta shei ta
    >>> print (str1.replace('shi','ta',1))
    ni ta wo shi shei shi

    24.split

    1
    2
    3
    4
    5
    6
    split(self, sep=None, maxsplit=None)通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
    >>> str1 = 'a1 b2 c3 d4'
    >>> print (str1.split())
    ['a1', 'b2', 'c3', 'd4']
    >>> print (str1.split(' ',2))
    ['a1', 'b2', 'c3 d4']

    25.splitlines

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    splitlines(self, keepends=False)按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行
    >>> str1 = ' a1b2 c3 d4'
    >>> str1 = ' a1b2 c3 d4 '
    >>> print (str1)
        
    a1b2
    c3
    d4
        
    >>> print (str1.splitlines())
    ['', 'a1b2', 'c3', 'd4']
    >>> print (str1.splitlines(2))
    [' ', 'a1b2 ', 'c3 ', 'd4 ']

    26.startswith

    1
    2
    3
    4
    5
    6
    startswith(self, prefix, start=None, end=None)用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查
    >>> name = 'LIUyao'
    >>> print (name.startswith('LI'))
    True
    >>> print (name.startswith('ya'))
    False

    27.swapcase

    1
    2
    3
    4
    swapcase(self)用于对字符串的大小写字母进行转换
    >>> name = 'LIUyao'
    >>> print (name.swapcase())
    liuYAO

    28.translate

    1
    translate(self, table, deletechars=None)根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中，table -- 翻译表，翻译表是通过maketrans方法转换而来，deletechars -- 字符串中要过滤的字符列表。

    29.upper

    1
    2
    3
    4
    upper(self)将字符串中的小写字母转为大写字母
    >>> name = 'yaoyao'
    >>> print (name.upper())
    YAOYAO

    30.zfill

    1
    2
    3
    4
    5
    6
    zfill(self, width)返回指定长度的字符串，width -- 指定字符串的长度。原字符串右对齐，前面填充0。
    >>> str1 = 'a1 b2 c3 d4'
    >>> print (str1.zfill(10))
    a1 b2 c3 d4
    >>> print (str1.zfill(15))
    0000a1 b2 c3 d4

    三.列表

    具有以下方法：

    1、追加

    1
    2
    3
    4
    5
    append(self, p_object)用于在列表末尾添加新的对象，obj -- 添加到列表末尾的对象，该方法无返回值，但是会修改原来的列表。
    >>> lie =[1,2,3,4,5]
    >>> lie.append(6)
    >>> print (lie)
    [1, 2, 3, 4, 5, 6]

    2、统计

    1
    2
    3
    4
    count(self, value)用于统计某个元素在列表中出现的次数，value -- 列表中统计的对象，返回元素在列表中出现的次数。
    >>> lie = [1,2,3,4,5,1,2,3]
    >>> print (lie.count(2))
    2

    3、合并

    1
    2
    3
    4
    5
    6
    7
    8
    extend(self, iterable)用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），seq -- 元素列表，该方法没有返回值，但会在已存在的列表中添加新的列表内容
    >>> list1
    [1, 2, 3, 4, 5]
    >>> list2
    ['a', 'b', 'c', 'd', 'f']
    >>> list1.extend(list2)
    >>> list1
    [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'f']

    4、索引

    1
    2
    3
    4
    5
    index(self, value, start=None, stop=None)用于从列表中找出某个值第一个匹配项的索引位置，value -- 查找的对象，该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
    >>> list1
    [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'f']
    >>> print (list1.index('a'))
    5

    5、指定插入

    1
    2
    3
    4
    5
    6
    insert(self, index, p_object)用于将指定对象插入列表，index -- 对象obj需要插入的索引位置，obj -- 要插入列表中的对象，该方法没有返回值，但会在列表指定位置插
    >>> list1
    [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd']
    >>> list1.insert(2,'6')
    >>> list1
    [1, 2, '6', 3, 4, 5, 'a', 'b', 'c', 'd']

    6、删除最后一个元素

    1
    2
    3
    4
    5
    pop(self, index=None)用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，index-- 可选参数，要移除列表元素的对象，该方法返回从列表中移除的元素对象。
    >>> list1.pop()
    'f'
    >>> list1
    [1, 2, 3, 4, 5, 'a', 'b', 'c', 'd']

    7、指定删除

    1
    2
    3
    4
    5
    6
    remove(self, value)用于移除列表中某个值的第一个匹配项，value -- 列表中要移除的对象，该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
    >>> list1
    [1, 2, '6', 3, 4, 5, 'a', 'b', 'c', 'd']
    >>> list1.remove(5)
    >>> list1
    [1, 2, '6', 3, 4, 'a', 'b', 'c', 'd']

    8、反向存放

    1
    2
    3
    4
    5
    6
    reverse(self)用于反向列表中元素，该方法没有返回值，但是会对列表的元素进行反向排序。
    >>> list1
    [1, 2, '6', 3, 4, 'a', 'b', 'c', 'd']
    >>> list1.reverse()
    >>> list1
    ['d', 'c', 'b', 'a', 4, 3, '6', 2, 1]

    9、排序

    1
    2
    3
    4
    5
    sort(self, cmp=None, key=None, reverse=False)用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数，该方法没有返回值，但是会对列表的对象进行排序。
    >>> list1 = [1,2,3,4,5,7,8,6,5]
    >>> list1.sort()
    >>> list1
    [1, 2, 3, 4, 5, 5, 6, 7, 8]

    10、反序

    1
    sorted内建函数：对序列进行反序，并返回一个列表

    四.元祖

     

    元组的意义：

    元组可以在映射中当作键使用；

    元组作为很多内建函数和方法的返回值存在。

    元组的元素是不能被修改，但元素的元素能可以被被修改的

    具有以下方法：

    1.统计

    1
    2
    3
    4
    5
    >>> boy=('kelin','yaoyao','liuyao','shabi')
    >>> type(boy)
    <class 'tuple'>
    >>> boy.count('yaoyao')
    1

    2.索引

    1
    2
    >>> boy.index('liuyao')
    2

    五.字典

    当数据量达到上百万时，循环字典就不适合用dict.items()，因为首先会把一对对key和value转化为列表，然后在循环遍历输出，会增加内存使用。建议使用如下：

    1
    2
    3
    4
    5
    6
    7
    >>> a = {1:'a',2:'b'}
    >>> for k in aa:print(k,aa[k])
    (1, 'a')
    (2, 'b')
    >>> for k in aa.keys():print(k,aa[k])
    (1, 'a')
    (2, 'b')

    具有以下方法：

    1、删除字典内所有元素

    1
    2
    3
    4
    5
    6
    7
    clear(self)用于删除字典内所有元素，该函数没有任何返回值。
    >>> dic = {'k1':'v1','k2':'v2'}
    >>> dic
    {'k2': 'v2', 'k1': 'v1'}
    >>> dic.clear()
    >>> dic
    {}

    2、浅复制

    1
    2
    3
    4
    5
    copy(self)返回一个字典的浅复制。
    >>> dic = {'k1':'v1','k1':'v2'}
    >>> dic.copy()
    {'k1': 'v2'}
    >>>

    3、get

    1
    2
    3
    4
    5
    get(self, k, d=None)返回指定键的值，如果值不在字典中返回默认值，key -- 字典中要查找的键，default -- 如果指定键的值不存在时，返回该默认值值。
    >>> dic = {'k1':'v1','k2':'v2'}
    >>> dic.get('k1')
    'v1'
    >>>

    4、has_key

    1
    has_key(self, k)用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false，k -- 要在字典中查找的键。注：3.x已删除该函数

    5、items

    1
    2
    3
    4
    items(self)以列表返回可遍历的(键, 值) 元组数组。
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.items()
    dict_items([('age', '21'), ('name', 'yaoyao'), ('job', 'IT')])

    6、iteritems

    1
    iteritems(self)项可迭代。注：3.x已删除该函数

    7、iterkeys

    1
    iterkeys(self)key可迭代。注：3.x已删除该函数

    8、itervalues

    1
    itervalues(self)value可迭代。注：3.x已删除该函数

    9、keys

    1
    2
    3
    4
    keys(self)以列表返回一个字典所有的键。
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.keys()
    dict_keys(['age', 'name', 'job'])

    10、删除键

    1
    2
    3
    4
    5
    6
    pop(self, k, d=None)获取并在字典中移除，k -- 要在字典中查找的键。
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.pop('job')
    'IT'
    >>> dic
    {'age': '21', 'name': 'yaoyao'}

    11、popitem

    1
    2
    3
    4
    5
    6
    popitem(self)获取并在字典中移除
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.popitem()
    ('age', '21')
    >>> dic
    {'name': 'yaoyao', 'job': 'IT'}

    12、setdefault

    1
    2
    3
    4
    5
    setdefault(self, k, d=None)如果key不存在，则创建，如果存在，则返回已存在的值且不修改
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.setdefault('sex')
    >>> dic
    {'sex': None, 'age': '21', 'name': 'yaoyao', 'job': 'IT'}

    13、更新

    1
    2
    3
    4
    5
    6
    update(self, E=None, **F)更新
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic_1={'sex':'man'}
    >>> dic.update(dic_1)
    >>> dic
    {'sex': 'man', 'age': '21', 'name': 'yaoyao', 'job': 'IT'}

    14、values

    1
    2
    3
    4
    values(self)以列表返回字典中的所有值。
    >>> dic={'name':'yaoyao','age':'21','job':'IT'}
    >>> dic.values()
    dict_values(['21', 'yaoyao', 'IT'])

    15、viewitems

    1
    viewitems(self)所有项，只是将内容保存至view对象中。注：3.x已删除该函数
  • 相关阅读:
    ios本地推送
    ios BUG
    性能优化
    数据结构设计
    代码的可维护性
    NSMutalbleDictionary
    NSDictionary
    NSMutableArray
    java 容器
    Java bug
  • 原文地址：https://www.cnblogs.com/xiongli/p/5790772.html
Copyright © 2011-2022 走看看