2.python基础深入(元组、字符串、列表、字典)
一，对象与类
对象：
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=20print(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.2f2 = 10.0print(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'\xc1\xf5\xd2\xab'>>> |
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 符号('\t')转为空格，默认的空格数 tabsize 是 8例：>>> extab = 'one\ttwo'>>> 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 = '\na1b2 c3 d4'>>> str1 = '\na1b2\nc3\nd4\n'>>> print (str1) a1b2c3d4 >>> print (str1.splitlines())['', 'a1b2', 'c3', 'd4']>>> print (str1.splitlines(2))['\n', 'a1b2\n', 'c3\n', 'd4\n'] |
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已删除该函数 |
