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})