python 类属性 static python 类属性声明数据类型

基本数据类型

一、类与对象

  类顾名思义，就是一类事物、或者叫做实例，它用来描述具有共同特征的一类事物。我们在python中声明类的关键词是class，类还有功能和属性，属性就是这类事物的特征，而功能就是它能做什么，也是就是方法或者函数。在python中，一切事物都是对象，而对象是基于类创建的。

1 id1 = int(1) #其中int就是类，而id1是int的对象
2 id2 = int(2) #其中int就是类，而id2是int的对象

  在上述代码中，id1可以使用int类中所有函数，id2也可以，对象可以指向生成它的类的地址。

  所以，所有字符串都是字符串类，数字都是数字类，列表都是列表类，并且生成它们的都是不同的类。

  查看对象相关可以用以下命令：

age = -19
print(vars(int)) #实现返回对象object的属性和属性值的字典对象
print(type(age)) #可以查看age变量属于什么类型
print(dir(int))  #可以查看int类内有哪些函数/方法

二、整数

例如：2、4、100

每个整数类的对象都具备以下方法（常用的）:

1、bit_length(self)表示该数字的时占用的最少位数

age = -19
print(age.bit_length())

2、__abs__(self)绝对值函数

age = -19
print(age.__abs__())

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

age = -19
age1 = -20
print(age1.__cmp__(age))

　

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

age = -19
age1 = -20
print(age1.__coerce__(age))

5、__divmod__(self, y)两个数相除，得到商和余数组成的元组

age = 19
age1 = 3
print(age.__divmod__(age1))

三、长整型

例如：2147483649、9223372036854775807

具备方法：同整型

四、浮点型

例如：0.75  19.234

1、as_integer_ratio(self) 获取改值的最简比

f1 = 0.75
print(f1.as_integer_ratio())

其余方法同整型

五、字符串

例如：'hetan'、'liuyao'

每个字符串类的对象都具备以下方法（常用的）:

1、capitalize(self)首字母变大写

name = 'hetan'
print(name.capitalize())

2、center(self, width, fillchar=None)内容居中显示，width：设置总长度，fillchar：空白处填充内容，默认为空

name = 'hetan'
print(name.center(30,'#'))

3、count(self, sub, start=None, end=None)子序列个数 sub：要查询的子序列 start：开始位置 end：结束位置

name = 'hetanst1stdfjlhgffkhkfdsgdhklh'
print(name.count('st',2,15))

　

4、encode(self, encoding=None, errors=None）编码，针对unicode  encoding='解码的格式'

name = '何潭'
print(name.encode('gbk'))

5、endswith(self, suffix, start=None, end=None)是否以xxx结尾 suffix：填入结尾的字符串  start=在第几个字符开始  end=在第几个字符结束

name = 'sdlkfdslksb'
print(name.endswith('lk',0,4))

6、expandtabs(self, tabsize=None)将tab转换成空格，默认一个tab转换成8个空格

name = 'sdlkf\tdslksb'
print(name.expandtabs(20))

7、find(self, sub, start=None, end=None)寻找子序列位置，如果没找到，返回 -1 

name = 'sdlkfdslksb'
print(name.find('kf',1,7))
print(name.find('kf',1,3))

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

name = 'HETAN'
print(name.casefold())

9、format(*args, **kwargs)字符串格式化

name = '何潭'
age = 26
print('{0}今年{1} '.format(name,age))

　

10、index(self, sub, start=None, end=None)子序列位置，如果没找到，报错

name = 'sdkgkfjsjdfjslf'
print(name.index('js'))
print(name.index('js',1,2))

11、isalnum(self)如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

st1 = 'this2016'
print(st1.isalnum())
st1 = 'this is 2016'
print(st1.isalnum())

12、isalpha(self)如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

st1 = 'this'
print(st1.isalpha())
st1 = 'this is a dog!!!'
print(st1.isalpha())

13、isdigit(self)如果字符串只包含数字则返回 True 否则返回 False

st1 = '2016'
print(st1.isdigit())
st1 = 'this2016'
print(st1.isdigit())

 14、islower(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

st1 = 'this is example'
print(st1.islower())
st1 = 'This is example'
print(st1.islower())

15、isspace(self)如果字符串中只包含空格，则返回 True，否则返回 False

st1 = '    '
print(st1.isspace())
st1 = 'This is example'
print(st1.isspace())

16、istitle(self)如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False

st1 = 'This Is Example'
print(st1.istitle())
st1 = 'This is example'
print(st1.istitle())

　

17、isupper(self)如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

st1 = 'THIS IS EXAMPLE'
print(st1.isupper())
st1 = 'This is example'
print(st1.isupper())

18、join(self, iterable)返回通过指定字符连接序列中元素后生成的新字符串

st1 = '_'
name = ('h','e','t','a','n')
print(st1.join(name))

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

st1 = 'hetan'
print(st1.ljust(20,'%'))

20、lower(self)返回将字符串中所有大写字符转换为小写后生成的字符串

st1 = 'This Is 2016'
print(st1.lower())

21、lstrip(self, chars=None)返回截掉字符串左边的空格或指定字符后生成的新字符串

st1 = '    This Is 2016     '
print(st1.lstrip())
st1 = '******This is 2016*****'
print(st1.lstrip('*'))

 22、partition(self, sep)返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串

st1 = 'This Is 2016'
print(st1.partition('Is'))

23、replace(self, old, new, count=None)返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次

st1 = 'This is 2016'
print(st1.replace('is','was'))
print(st1.replace('is','was',1))

24、split(self, sep=None, maxsplit=None)通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

st1 = 'This is 2016'
print(st1.split())
print(st1.split(' ',1))

25、splitlines(self, keepends=False)按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行

st1 = '\nThis\nis\n2016\n'
print(st1)
print(st1.splitlines())
print(st1.splitlines(0))
print(st1.splitlines(1))
print(st1.splitlines(2))
print(st1.splitlines(3))

26、startswith(self, prefix, start=None, end=None)用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查

st1 = 'This is 2016'
print(st1.startswith('Th'))
print(st1.startswith('Th',1,4))

27、strip(self, chars=None)用于移除字符串头尾指定的字符（默认为空格）

st1 = '  *This is 2016*   '
print(st1.strip())
print(st1.strip().strip('*'))

28、swapcase(self)用于对字符串的大小写字母进行转换

st1 = 'This is 2016'
print(st1.swapcase())

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

inttab = 'aeiou'
outtab = '12345'
trantab = ''.maketrans(inttab,outtab)
st1 = 'This is a egg'
print(st1.translate(trantab))
print(trantab)

30、upper(self)将字符串中的小写字母转为大写字母

st1 = 'This is a egg'
print(st1.upper())

31、zfill(self, width)返回指定长度的字符串，width -- 指定字符串的长度。原字符串右对齐，前面填充0。

st1 = 'This is a egg'
print(st1.zfill(20))

六、列表

例如：[1,2,3,4,5]，['hetan','liuyao']

每个列表类的对象都具备以下方法（常用的）:

1、append(self, p_object)用于在列表末尾添加新的对象，obj -- 添加到列表末尾的对象，该方法无返回值，但是会修改原来的列表。

li = ['This', 'is', 'a', 'egg']
li.append('eggg')
print(li)

2、count(self, value)用于统计某个元素在列表中出现的次数，value -- 列表中统计的对象，返回元素在列表中出现的次数。

li = ['This', 'is', 'a', 'egg','egg']
print(li.count('egg'))

3、extend(self, iterable)用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），seq -- 元素列表，该方法没有返回值，但会在已存在的列表中添加新的列表内容。

li = ['This', 'is', 'a', 'egg',]
li1 = ['good','boy']
li.extend(li1)
print(li)

4、index(self, value, start=None, stop=None)用于从列表中找出某个值第一个匹配项的索引位置，value -- 查找的对象，该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

li = ['This', 'is', 'a', 'egg','is',]
print(li.index('is'))
print(li.index('is',3,6))

5、insert(self, index, p_object)用于将指定对象插入列表，index -- 对象obj需要插入的索引位置，obj -- 要插入列表中的对象，该方法没有返回值，但会在列表指定位置插入对象。

li = ['This', 'is',  'egg',]
li.insert(2,'a')
print(li)

6、pop(self, index=None)用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，index-- 可选参数，要移除列表元素的对象，该方法返回从列表中移除的元素对象。

li = ['This', 'is','a','egg',]
li.pop()
print(li)
li.pop(1)
print(li)

7、remove(self, value)用于移除列表中某个值的第一个匹配项，value -- 列表中要移除的对象，该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

li = ['This', 'is','a','egg',]
li.remove('is')
print(li)

 8、reverse(self)用于反向列表中元素，该方法没有返回值，但是会对列表的元素进行反向排序。

li = ['This', 'is','a','egg',]
li.reverse()
print(li)

9、sort(self, cmp=None, key=None, reverse=False)用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数，该方法没有返回值，但是会对列表的对象进行排序。

li = ['This', 'is','a','egg',]
li.sort()
print(li)

七、元组

例如：(11,22,33)、('liuyao','hetan')

每个元组类的对象都具备以下方法（常用的）:

1、count(self, value)用于统计某个元素在元组中出现的次数，value -- 元组中统计的对象，返回元素在元组中出现的次数。

li = ('This', 'is','a','egg','a')
print(li.count('a'))

2、index(self, value, start=None, stop=None)用于从元组中找出某个值第一个匹配项的索引位置，value -- 查找的对象，该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

li = ('This', 'is','a','egg','a')
print(li.index('a'))
print(li.index('a',3,6))

八、字典

例如：{'name':'hetan','age':26}

每个字典类的对象都具备以下方法（常用的）:

1、clear(self)用于删除字典内所有元素，该函数没有任何返回值。

dic = {'name':'hetan','age':26}
dic.clear()
print(dic)

2、copy(self)返回一个字典的浅复制。

dic1 = {'name':'hetan','age':26}
print(dic1.copy())

3、get(self, k, d=None)返回指定键的值，如果值不在字典中返回默认值，key -- 字典中要查找的键，default -- 如果指定键的值不存在时，返回该默认值值。

dic = {'name':'hetan','age':26}
dic1 = 'value : %s' %(dic.get('name'))
print(dic1)

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

dic = {'name':'hetan','age':26}
print(dic.has_key('name'))
print(dic.has_key('sex'))

5、items(self)以列表返回可遍历的(键, 值) 元组数组。

dic = {'name':'hetan','age':26}
print(dic.items())

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

dic = {'name':'hetan','age':26}
for i in dic.iteritems():
    print(i)

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

dic = {'name':'hetan','age':26}
for i in dic.iterkeys():
    print(i)

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

dic = {'name':'hetan','age':26}
for i in dic.itervalues():
    print(i)

9、keys(self)以列表返回一个字典所有的键。

dic = {'name':'hetan','age':26}
print(dic.keys())

10、pop(self, k, d=None)获取并在字典中移除，k -- 要在字典中查找的键。

dic = {'name':'hetan','age':26}
dic1 = dic.pop('name')
print(dic1)
print(dic)

11、popitem(self)获取并在字典中移除。

dic = {'name':'hetan','age':26}
dic1 = dic.popitem()
print(dic1)
print(dic)

12、setdefault(self, k, d=None)如果key不存在，则创建，如果存在，则返回已存在的值且不修改

dic = {'name':'hetan','age':26}
dic.setdefault('sex','men')
print(dic)
dic2 = dic.setdefault('job')
print(dic2)

13、update(self, E=None, **F)更新

dic = {'name':'hetan','age':26}
dic1 = {'sex':'men'}
dic.update(dic1)
print(dic)

14、values(self)以列表返回字典中的所有值。

dic = {'name':'hetan','age':26}
print(dic.values())

15、viewitems(self)所有项，只是将内容保存至view对象中。注：3.x已删除该函数

dic = {'name':'hetan','age':26}
print(dic.viewitems())

 

练习：有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

1 li = [11,22,33,44,55,66,77,88,99]
2 dic = {'k1':[],'k2':[]}
3 for i in li:
4     if i > 66:
5         dic['k1'].append(i)
6     else:
7         dic['k2'].append(i)
8 print(dic)

demo