python中必须掌握的基础数据类型及其相互转换

python中的几种读取图片的方式：点击此处

python需要掌握的图片类型间的转换：点击此处

python中常用的数据类型：int、bool、str、list、dict、tuple、set。

int：十进制转换为二进制：除2取余，逆向排列

       二进制转化为十进制：记住8位一节

常用操作方法：bit_length()获取十进制转化为二进制的最小位数

i = 42
print(i.bit_length())  ---->6

bool：零代表假，其他数字代表真

str：对字符串的操作会形成新的字符串，与原字符串没有任何关系。（不会改变元字符串）

常用操作方法：索引与切片、capitalize()、swapcase()、center()、title()、upper()、lower()、startswith()、endswith()、find()、index()、strip()、lstrip()、rstrip()、split()、rsplit()、replace()、join()、format()、isalnum()、isalpha()、isdigit()、count()、len()

索引与切片

s1 = 'peopleigreat'
print(s1[0])            ------->'p'
print(s1[-1])           ------->'t'
print(s1[0:4])          ------->'peop'
print(s1[:4])           ------->'peop'
print(s1[2:-1])         ------->'opleigreat'
print(s1[:5:2])         ------->'pol'
print(s1[-1:-3:-1])     ------->'ta'

capitalize()：首字母大写，其余字母小写

s1 = 'peopleisgreat'
print(s1.capitalize())  -------->'Peopleisgreat'

swapcase()：大小写反转

s1 = 'peopleisgreat'
print(s1.swapcase())  -------->'PEOPLEISGREAT'

center()：在字符串中可设置长度，并且可设置填充物

s1 = 'peopleisgreat'
print(s1.center(20))       ------->'    peopleisgreat     '
print(s1.center(20), '*')  ------->'****peopleisgreat*****'

title()：字符串中非字母元素隔开的每一个单词的首字母大写

s1 = 'people is*great'
print(s1.title())  ----->'People Is*Great'

upper()：全部变大写

lower()：全部变小写

s1 = 'peopleisgreat'
print(s1.upper())  ------>'PEOPLEISGREAT'
print(s1.lower())   ------>'peopleisgreat'

startswith()：判断该字符串以某个字符或者某些字符为开头，并且可以切片，返回的是bool值

endswith()：判断该字符串以某个字符或者某些字符为结尾，并且可以切片，返回的是bool值

s1 = 'peopleisgreat'
print(s1.startswith('p'))          ----->True
print(s1.startswith('po'))         ------>False
print(s1.startswith('people'))     ------>True
print(s1.startswith('i', 6, ))     ------>True

find()：通过元素找索引，找到第一个元素就返回，找不到该元素就返回-1

index()：和find()方法的功能几乎一样，唯一不一样的就是当找不到元素的时候就会报错

s1 = 'peopleisgreat'
print(s1.find('i'))         ------>6
print(s1.find('is'))        ------>6
print(s1.find('i', 3, -1))  ------>6
print(s1.find('y'))         ------>-1
print(s1.find('e'))         ------>1

strip()：默认去除字符串前后两侧的换行符、置零符、空格，还可以去除指定字符

s1 = '  peopleisgreat   '
s2 = '  \tpeopleisgreat\n   '
s3 = 'qwwwwwwwpeopleisgreatqqwwwtt'
s4 = 'qwwwawwwwpeopleisgreatqqwwwtt'
print(s1.strip())       ------>'peopleisgreat'
print(s2.strip())       ------>'peopleisgreat'
print(s3.strip('qwt'))  ------>'peopleisgrea'
print(s3.strip('qwt'))  ------>'awwwwpeopleisgrea'

lstrip()：默认去除左端的换行符、置零符、空格，还可以去除指定字符

rstrip()：默认去除右端的换行符、置零符、空格，还可以去除指定字符

split()：默认以空格分割成列表，可设置分隔符和分割次数，str--->list

s1 = 'people is great'
s2 = 'people:is:great'
s3 = ':people:is:great'
s4 = ':people:is:great'
print(s1.split())        ------>['people', 'is', 'great']
print(s2.split(':'))     ------>['people', 'is', 'great']
print(s3.split(':'))     ------>['', 'people', 'is', 'great']
print(s4.split(':', 1))  ------>['', 'people:is:great']

rsplit()：从右往左分割

replace()：替换掉指定的字符内容，还可以指定替换的次数

s1 = 'people is great great great'
print(s1.replace('great', 'good'))    ----->'people is good good good'
print(s1.replace('great', 'good', 1)) ----->'people is good great great'

join()：将字符串的每个字符通过设置的连接符连接起来，形成一个新的字符串，list--->str（前提是列表中的元素必须是字符串）

s1 = 'people is great'
s2 = ['alex', '太白', 'wusir']
print('_'.join(s1))  ----->'p_e_o_p_l_e_ _i_s_ _g_r_e_a_t'
print('_'.join(s2))  ----->'alex_太白_wusir'

format()：格式化输出

msg = '我叫{}，今年{}，爱好{}'
msg1 = '我叫{0}，今年{1}，爱好{2}，我依然叫{0}'
msg2 = '我叫{name}，今年{age}，爱好{hobby}'
print(msg.format('太白','25','美女'))                  ---->'我叫太白，今年25，爱好美女'
print(msg1.format('太白','25','美女'))                 ---->'我叫太白，今年25，爱好美女，我依然叫太白'
print(msg2.format(age='25', hobby='美女', name='太白'))---->'我叫太白，今年25，爱好美女'

isalnum()：判断字符串是否由字母或数字组成

isalpha()：判断字符串是否只由字母组成

isdigit()：判断字符串是否只由数字组成

name='taibai123'
print(name.isalnum()) ----->True
print(name.isalpha()) ----->False
print(name.isdigit()) ----->False

count()：计算字符串中某元素出现的个数，可以切片

s1 = 'alalalphahgjsgghgjsdhg'
print(s1.count('a'))   ----->4
print(s1.count('al'))  ----->3

len()：这是公共方法，计算字符串的长度

s1 = 'alalalphahgjsgghgjsdhg'
print(len(s1))   ----->22

list：容器型数据类型，可以储存任意数据类型，也可以存储大量的数据。但是任何人都拥有更改它的权限，不安全。

常用操作方法：索引切片步长、增（append()、insert()、extend()）删（pop()、remove()、clear()、del()）改（按照索引去改、按照切片去改、按照切片（步长）去改）查（索引、切片、切片（步长））、count()、index()、sort()、reverse()、len()

索引切片步长：顾头不顾尾

s = [1, 2, 'alex', '太白']
print(s[1])    ----->2
print(s[-1])   ----->'太白'
print(s[:2])   ----->[1, 2]
print(s[::2])  ----->[1, 'alex']

append()：追加

s = [1, 2, 'alex', '太白']
print(s.append('太阳'))  ----->[1, 2, 'alex', '太白', '太阳']

insert()：插入

s = [1, 2, 'alex', '太白']
print(s.insert(1, '泰迪'))  ---->s = [1, 2, 'alex', '太白', '泰迪']

extend()：迭代追加（要求可迭代对象）

s = [1, 2, 'alex', '太白']
print(s.extend([3, 4, 'rei'])) ----->[1, 2, 'alex', '太白', 3, 4, 'rei']

pop()：按照索引去删除，有返回值，返回值是被删除的值

s = [1, 2, 'alex', '太白']
print(s.pop(0))  ----->1

remove()：按照元素取删除

s = [1, 2, 'alex', '太白']
s.remove(2)     
print(s)          ----->[1, 'alex', '太白']

clear()：清空

s = [1, 2, 'alex', '太白']
s.clear()
print(s)     ----->[]

del()：按照索引删除，可以按照切片（步长）删除

s = [1, 2, 'alex', '太白', 'rere', 4]
del s[0]
print(s)      ----->[2, 'alex', '太白', 'rere', 4]
del s[:2]
print(s)      ----->['太白', 'rere', 4]
del s[::2]
print(s)      ----->['rere']

按照索引去改

s = [1, 2, 'alex', '太白', 'rere', 4]
s[0] = 44
print(s)           ----->[44, 2, 'alex', '太白', 'rere', 4]

按照切片去改：将切片部分内容清空，可迭代对象的每一个元素添加到这个部分

s = [1, 2, 'alex', '太白']
s[2:] = 'rere'
print(s)      ----->[1, 2, 'r', 'e', 'r', 'e']
s[:3] = [1, 2, 3, 4]
print(s)      ----->[1, 2, 3, 4, 'e', 'r', 'e']

按照切片（步长）去改：内容和空格必须一致

s = [1, 2, 'alex', '太白']
s[::2] = ['ab', 'cd']
print(s)         ----->['ab', 2, 'cd', '太白']

count()：计算某元素出现的次数

s = [1, 2, 'alex', '太白', 2]
print(s.count(2))      ----->2

index()：按照元素找到其对应的索引

s = [1, 2, 'alex', '太白']
print(s.index('alex'))       ----->2

sort()：默认从小到大排序

s = [1, 4, 6, 2, 7, 3]
s.sort()
print(s)     ----->[1, 2, 3, 4, 6, 7]
s.sort(reverse=True)
print(s)     ----->[7, 6, 4, 3, 2, 1]

reverse()：翻转

s = [1, 4, 6, 2, 7, 3]
s.reverse()
print(s)        ----->[3, 7, 2, 6, 4, 1]

len()：计算列表的长度

s = [3, 7, 2, 6, 4, 1]
print(len(s))       ----->6

tuple：为了一些重要的数据不需要别人进行更改，引进了元组。它也是容器型数据类型，它只能查询，不能增删改查（在某些条件下）。如果在元组里有个元素是列表或者字典，这个列表或者字典整体是不可以更改的，但是列表或字典里面的元素是可以更改的。但是这样的方式一般不太推荐使用。它里面放的一般是固定的重要的不需要被更改的元素。

常用基本功能：索引、切片（步长）、count()、index()

索引、切片（步长）：

s = (1, 2, 'alex', '太白')
print(s[1])     ----->2
print(s[:3])    ----->(1, 2, 'alex')
print(s[::2])   ----->(1, 'alex')

count()：查询元素出现的次数

s = (1, 2, 'alex', '太白', '太白')
print(s.count('太白'))    ----->2

index()：按照元素查询其对应的索引

s = (1, 2, 'alex', '太白', '太白')
print(s.index('太白'))    ----->3

dict：它是属于可变数据类型（dict、list、set），而不可变数据类型有（str、int、bool、tuple）。它的查询速度非常快，因为用到了哈希算法。字典的键值对是不可重复的，如果出现重复的键时，其对应的值一样的话，就合并成一个，如果其对应的值不一样，就按照最后一个进行计算。如果直接循环一个字典，默认是循环其键值。

常用操作方法：增（直接增加、setdefault()）删（pop()、clear()、del）改（按照键改、update()）查（按照键查、get()）、keys()、values()、items()

直接增加：有此键则更改，无此键则增加

s = {'name':'太白', 'age':24, 'sex':'男'}
s['high'] = 175
print(s)           ----->{'name': '太白', 'age': 24, 'sex': '男', 'high': 175}
s['name'] = 'alex'
print(s)           ----->{'name': 'alex', 'age': 24, 'sex': '男', 'high': 175}

setdefault()：有此键则不变，无此键则增加

s = {'name':'太白', 'age':24, 'sex':'男'}
s1 = {'name':'太白', 'age':24, 'sex':'男'}
s.setdefault('weight')
print(s)     ----->{'name': '太白', 'age': 24, 'sex': '男', 'weight': None}
s.setdefault('name', 'alex')
print(s)     ----->{'name': '太白', 'age': 24, 'sex': '男', 'weight': None}
s1.setdefault('weight', 150)
print(s1)    ----->{'name': '太白', 'age': 24, 'sex': '男', 'weight': 150}

pop()：按照键去删除键值对，有返回值，返回值是将要删除的值。pop中的第二个参数可以设置返回值，如果没有你要删除的键值对，但是你删除了并且不想让他报错，就设置第二个参数。所以一般推荐使用这个方法，即使没有对应的键值也不会报错。

s = {'name':'太白', 'age':24, 'sex':'男'}
s.pop('name')
print(s)     ----->{'age': 24, 'sex': '男'}

clear()：清空字典

s = {'name':'太白', 'age':24, 'sex':'男'}
s.clear()
print(s)     ----->{}

del：按照键值进行删除，如果没有对应的键值就会报错。

s = {'name':'太白', 'age':24, 'sex':'男'}
del s['name']
print(s)     ----->{'age': 24, 'sex': '男'}

按照键改：同上

s = {'name':'太白', 'age':24, 'sex':'男'}
s['name'] = 'alex'
print(s)      ----->{'name': 'alex', 'age': 24, 'sex': '男'}

updade()：将括号内的所有键值对覆盖添加（相同的键覆盖，不同的键值对添加）到括号前面的字典中，并且括号内的字典保持不变。

s0 = {'name':'太白', 'age':24, 'sex':'男'}
s = {'name':'太白', 'age':24, 'sex':'男'}
s1 = {'name':'alex', 'weight':150}
s.update(s1)
s0.update(name='alex', weight=150)
print(s0)   ----->{'name': 'alex', 'age': 24, 'sex': '男', 'weight': 150}
print(s)     ----->{'name': 'alex', 'age': 24, 'sex': '男', 'weight': 150}
print(s1)    ----->{'name': 'alex', 'weight': 150}

按照键查：如果没有对应的键值就会报错

s = {'name':'太白', 'age':24, 'sex':'男'}
print(s['name'])    ----->'太白'
print(s['name1'])  ----->KeyError: 'name1'

get()：如果没有对应的键值就返回None，而不会报错，它也可以设置返回键。

s = {'name':'太白', 'age':24, 'sex':'男'}
print(s.get('name'))              ----->'太白'
print(s.get('name1'))             ----->None
print(s.get('name1', '没有此键'))  ----->'没有此键'

 keys()：产生类似于列表的容器型数据类型。不支持索引，可以转换为列表。它还可以直接进行for循环。

s = {'name':'太白', 'age':24, 'sex':'男'}
ret = s.keys()
print(ret)       ----->dict_keys(['name', 'age', 'sex'])
print(ret[0])    ----->TypeError: 'dict_keys' object does not support indexing
for i in ret:
    print(i)     ----->name
                       age
                       sex

values()：产生类似于列表的容器型数据类型。不支持索引，可以转换为列表。它还可以直接进行for循环。

s = {'name':'太白', 'age':24, 'sex':'男'}
ret = s.values()
print(ret)       ----->dict_values(['太白', 24, '男'])
print(ret[0])    ----->TypeError: 'dict_values' object does not support indexing
for i in ret:
    print(i)     ----->'太白'
                       24
                       '男'

items()：键值对，产生类似于列表的容器型数据类型。不支持索引，可以转换为列表。它还可以直接进行for循环。

s = {'name':'太白', 'age':24, 'sex':'男'}
ret = s.items()
print(ret)       ----->dict_items([('name', '太白'), ('age', 24), ('sex', '男')])
print(ret[0])    ----->TypeError: 'dict_items' object does not support indexing
for i in ret:
    print(i)     ----->('name', '太白')
                       ('age', 24)
                       ('sex', '男')

set：以上已经拥有了三个容器型数据类型：列表、字典和元组。集合的两个最主要的功能是：列表的去重和关系测试（交集、并集、差集等）。他是无序的，并且天然去重。集合里面的元素必须是不可变的数据类型。在集合里的元素不可有不可哈希的容器型数据类型, 集合是无序的。

常用操作方法：列表去重、增（add()、update()）删（remove()、pop()、clear()、del）查（for循环）、关系测试（交集（&或intersection()）并集（|或union()）差集（-或difference()）对称差集（^或symmetric_difference()） 超集（或issuperset()）子集（<或issubset()）冻集合）

列表去重：

s = [1, 2, 1, 2, 3, 4, 1, 4, 5]
set1 = set(s)
s = list(set1)
print(s)      ----->[1, 2, 3, 4, 5]

add()：增加一个元素

s = {'alex', 'taibai', '太白'}
s.add('tiantian')
print(s)        ----->{'alex', '太白', 'taibai', 'tiantian'}

update()：迭代着增加多个元素

s = {'alex', 'taibai', '太白'}
s.update('alex')
print(s)   ----->{'e', 'l', 'a', 'x', 'alex', '太白', 'taibai'}
s.update([1, 2, 3])
print(s)   ----->{1, 2, 3, 'e', 'l', 'a', 'x', 'alex', '太白', 'taibai'}

remove()：按照元素删除

s = {'alex', 'taibai', '太白'}
s.remove('alex')
print(s)      ----->{'太白', 'taibai'}

pop()：随机删除，有返回值，返回值为被删除的值。

s1 = {'alex', 'taibai', '太白'}
s2 = {'alex', 'taibai', '太白'}
print(s1.pop())   ----->'alex'
print(s1)            ----->{'taibai', '太白'}
print(s2.pop())   ----->'alex'
print(s2)            ----->{'taibai', '太白'}

clear()：清空

s = {'alex', 'taibai', '太白'}
s.clear()
print(s)       ----->set()

del：删除整个集合

s = {'alex', 'taibai', '太白'}
del s
print(s)        ----->NameError: name 's' is not defined

 交集：&或者intersection()

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1 & set2)                    ----->{3, 4, 5}
print(set1.intersection(set2))        ----->{3, 4, 5}

并集：|或者union()

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1 | set2)            ----->{1, 2, 3, 4, 5, 6, 7}
print(set1.union(set2))       ----->{1, 2, 3, 4, 5, 6, 7}

差集：-或者difference()

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1 - set2)               ----->{1, 2}
print(set1.difference(set2))     ----->{1, 2}

对称差集：^或者symmetric_difference()

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
print(set1 ^ set2)                      ----->{1, 2, 6, 7}
print(set1.symmetric_difference(set2))  ----->{1, 2, 6, 7}

 超集：>或issuperset()

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
print(set1 > set2)               ----->True
print(set1.issuperset(set2))     ----->True

子集：<或issubset()

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
print(set2 < set1)               ----->True
print(set2.issubset(set1))       ----->True

冻集合：集合是可变的数据类型，如果你不想让她变动，就可以通过frozenset()来实现。变成冻集合之后，就不可以对其进行增加和删除操作了。也可以对其进行for循环操作。

set1 = {1, 2, 3, 4, 5}
fro = frozenset(set1)
print(fro)            ----->frozenset({1, 2, 3, 4, 5})