其中:
内置的 type() 函数和isinstance()函数来判断。
示例
#type()判断
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
#输出
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
#isinstance()判断
a = 111
isinstance(a, int)
#输出
True
整数:int 小数:float 复数complex
布尔:bool
int | float | complex |
---|---|---|
10 | 0.0 | 3.14j |
100 | 15.20 | 45.j |
-786 | -21.9 | 9.322e-36j |
080 | 32.3e+18 | .876j |
-0490 | -90. | -.6545+0J |
-0x260 | -32.54e100 | 3e+26J |
0x69 | 70.2E-12 | 4.53e-7j |
当给变量指定一个值时,数值 对象就会被创建:
var1 = 1
var2 = 10
数值的运算
5 + 4 # 加法
9
4.3 - 2 # 减法
2.3
3 * 7 # 乘法
21
2 / 4 # 除法,得到一个浮点数
0.5
2 // 4 # 除法,得到一个整数
0
17 % 3 # 取余
2
2 ** 5 # 乘方
32
var1 + var2
11
布尔:bool值(真和假)
True为真,False为假
bool isTrue = True;
bool isFalse = True;
布尔值一般用来做判断。
提示:
Python中的字符串用单引号 ’ 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。
三引号的作用是直接输出多行字符串
a = 'hello'
b = "hello"
c = "let's go"
d = 'let\'s go'
字符串取值
str1 = 'hello world python'
#索引字符串第1个字符
str1 [0]
#索引字符串中前三个字符
str1 [0:3]
#索引字符串中前三个字符
str1 [:3]
#s[start:end:step] 取从0开始,到3结束,字符串步长为2 'hl'
str1 [0:4:2]
#倒叙输出整个字符串 'nohtyp dlrow olleh'
str1 [::-1]
#从第二个字符开始输出 'ello world python'
str1 [1:]
#输出最后一个字符
str1 [-1] 'n'
#从倒数第二个字符开始往前输出 'hello world pytho'
str1 [:-1]
拼接字符串
str1 = 'hello'
str2 = 'world'
#拼接
str3 = str1 + str2 + 'python'
大小写转换
#小写转换为大写输出HELLO
'hello'.upper()
#大写转换为小写输出hello
'heLLo'.lower()
去除字符串空格
可以将\n,\t,’ '产生的空格全部去掉
str1 = 'hello world python'
#使左右两边空格全部去掉
str1.stirp()
#使右边的空格去掉
str1.rstrip()
#使左边的空格去掉
str1.lstrip()
str2 = 'helloh'
#结果为'ello'##将两边h去掉
str2.strip('h')
字符串对齐
#居中,左右各10空格
print('python学习'.center(10))
#居中,左右各10个#
print('python学习'.center(10,'#'))
#左对齐,右边10个#
print('python学习'.ljust(10,'#''))
#右对齐,左边10个#
print('python学习'.rjust(10,'#''))
字符串查找
str1 = 'hello world python'
#l的个数
str1.count('l')
#str1的长度
len(str1)
#查找w出现的索引位置
str1.find('w')
#查询p出现的索引位置
str1.index('p')
字符串切割替换
split() 字符串切割
replace 字符或字符串替换
str1 = 'hello world python'
#以o为分隔符分离,res接收分割后的结果,res是一个列表类型
res = str1.split('o')
#结果如下
['hell', ' w', 'rld pyth', 'n']
#把某个字符或者字符串用字符或字符串替换 把'o' 用lx替换
res.replace('o','lx') #结果'helllx wlxrld pythlxn'
#把python这个字符串用'woaini'替换,结果'hello world woaini'
res.replace('python','woaini')
字符集拼接
str1 = 'hello'
str2 = 'world'
#拼接
str3 = str1 + str2 + 'python'
str1 = 'hello world python'
#以o为分隔符分离,res接收分割后的结果,res是一个列表类型 ['hell', ' w', 'rld pyth', 'n']
res = str1.split('o')
#join拼接 以空格进行拼接结果'hell w rld pyth n'
res2 = ' '.join(res)
#%s占位符方式拼接 'hello world python'
res3 = '%s %s %s'%('hello','world','python')
#format方式拼接 'hello world python'
res4 = '{} {} {}'.format('hello','world','python')
格式化输出,适用于format
%s 字符串输出
%d 输出整数(十进制输出)
%f 小数的输出
%c 把整数转换为ASCII码输出或单个字符
%o 八进制(转换为8进制输出)
%x 十六进制(转换为16进制输出)
%e 以科学计数法方式输出
%r 可以看出原本的对象是数值还是字符串
字符串编码
用什么格式编码的,解码也需要用对应的格式。
# utf8编码
byte1 = '云雾飞扬师长夷'.encode('utf8')
#编码后的结果
b'\xe4\xba\x91\xe9\x9b\xbe\xe9\xa3\x9e\xe6\x89\xac\xe5\xb8\x88\xe9\x95\xbf\xe5\xa4\xb7'
#解码
byte1.decode('utf8')
%f的扩展
#第一个5为输出的长度,2为指定小数的位数
%5.2f
print('%5.2f'%(25.65432))
#输出结果为25.65
#有符号的输出,右对齐,对于不足八位,前面用0补齐
%+08.2f
print('%+08.2f'%(-25.65432))
#输出结果为-0025.65
print('%+8.2f'%(-25.65432))
# -25.65 右对齐,前面不足用空格补齐
#左对齐,后面位数不足用空格补齐
print('%-8.2f'%(-25.65432))
format的扩展
str1 = 'hello'
str2 = 'world'
str3 = 'python'
print('{}+{}+{}'.format(str1,str2,str3))
#结果hello+world+python
#可以在大括号里面写上索引
print('{0} {2} {1}'.format(str1,str2,str3))
#结果hello python world
#可以在大括号内写上变量名
print('{grade},{name}'.format(name='python',grade = 64))
#结果64,python
#小数的输入输出
'{:.2f}'.format(12.33333)
#结果12.33
a=12.33333
b=2.6985
c=7828
'{:.2f} {} {}'.format(a,b,c)
#结果12.33 2.6985 7828
#百分比模式输入
'{:.2%}'.format(0.033)
#结果 3.30%
#位数补齐
'{:<10}'.format(12.3)
#结果'12.3 '左对齐,空格补齐10位,'<'是左对齐,'>'是右对齐
#居中对齐
'{:*^10}'.format(12.3)
#结果'***12.3***' 居中对齐,用*号补齐10位, '^'表示居中对齐
列表list
用来存储不同的数据类型,使用 [ ]来定义一个列表。
定义一个列表
#这个列表中存储的都是字符串
li1 = ['http','ssh','ftp']
#这个列表中都是数值
li2 = [2,3,4,5,9]
#混合类型
li3 = [2,3,4,5,9,'http','ssh','ftp']
索引取值
print(li1[1]) #输出第二个元素,ssh
print(li2[-1]) #输出最后一个元素,9
切片取值
print(li1[1:]) #打印第一个元素之后的内容
print(li2[:-1]) #打印最后一个元素之前的内容
print(li3[::-1]) #倒序输出
li2[1:3] #取头不取尾 结果3,4 左闭右开
li3[0:7:2] #步长取值,隔两个元素取值一次 [2, 4, 9, 'ssh']
列表链接
li4 = li2+li3
#结果
[2, 3, 4, 5, 9, 2, 3, 4, 5, 9, 'http', 'ssh', 'ftp']
列表嵌套
li5 = [['abcd','hello','world'],[1,2,3],['i','love','python']]
增加
#追加一个元素到列表中
li5.append('tanzhou')
#追加多个元素到列表中
li5.extend(['my','name','is','python'])
#在指定索引处插入元素
li5.insert(1,'hellotanzhou')
删除
#删除最后一个元素
li5.pop()
#删除第一个元素
li5.pop(0)
#指定删除对象的名字,不能指定序号,只能指定要删除对象
service.remove('python')
#删除整个列表
del li5
查询
#查看is在列表中出现的次数
li5.conut('is')
#查看指定元素的最小索引值
li5.index('is')
#从1-7中查找python这个元素的索引值,不取上限
li5.index('python',1,7)
修改
直接通过索引值来修改数据
#通过索引重新赋值
li5[1] = 'yes'
#通过切片给前两个元素重新赋值
li5[:2] = ['hello','world']
排序
sort()函数
对字符串排序不区分大小写
#按照ASCLL排序 先排序首字母为大写的,再排序首字母是小写的
names = ['alice','Bob','coco','Harry']
name.sort()
#对字符串排序不区分大小写,相当于将所有元素转换为小写,再排序
names.sort(key=str.lower)
#相当于将所有元素转换为大写,再排序
names.sort(key=str.upper)
元组(tuple):存储任意类型数据,但其内数据不可变。元组不可变,其内的列表中的元素可以变
元组的操作类似列表
#元组内类型任意
t1 = (1,2.3,True,'abc',[8,20,'hello'])
元组内列表的值可以修改
t1 = (1,2.3,True,'abc',[8,20,'hello'])
#修改元组内列表的值
t1[4].append('world')
#结果(1, 2.3, True, 'abc', [8, 20, 'hello', 'world'])
索引
print(t1[0])
#结果 1
切片
print(t1[1:]) #打印第一个元素之后的内容
print(t1[:-1]) #打印最后一个元素之前的内容
print(t1[::-1]) #倒序输出
t1[1:3] #取头不取尾 结果(2.3, True) 左闭右开
t1[0:7:2] #步长取值,隔两个元素取值一次 (1, True, [8, 20, 'hello', 'world'])
链接
t2 = ('abc','xyz','mn')
print(t2+('hello','world'))
#结果('abc', 'xyz', 'mn', 'hello', 'world')
查找
t3 = (1,2.3,True,'abc',[8,20,'hello',1,3,2.3,1],2.3,1,8,1)
#统计1出现的次数
print(t3.count(1))
#结果出现了4次,因为true 也是1 ,但是列表中的1不计入统计,所以共出现了4次
print(t3.index(8))
#查询8出现位置的最小索引,其中列表的中的8不算
排序
因为元组不可变,所以元组的方法没有排序,需要借助函数sorted
前提是元组内的数据是同一种类型。
t4 = (65,89,59,78,100)
#排序
sorted(t4)
#结果[59, 65, 78, 89, 100]
集合(set):存储元素不重复、无序数据类型,只支持成员操作赋、for循环迭代、枚举。
无序的数据类型,添加顺序和在集合中的存储顺序不一样。
不支持索引,重复,连接,切片。
集合用大括号表示{}
集合的定义
b = {1,2,3}
#空集合
c = set()
枚举
返回对应的元素和索引
s1 = {1,2,3,9,8,6,25,39,87,24,77,65}
#枚举取值
for i,value in enumerate(s1):
print('index:{},value:{}'.format(i,value))
交集&,并集|,差集-
s1 = {1,2,3,4}
s2 = {3,4,5,6,7}
#交集 两个集合共有的元素
s1&s2
#结果 {3, 4}
#并集,两个集合合并后所有的元素,重复项会合并
s1|s2
s1.union(s2)
#结果 {1, 2, 3, 4, 5, 6, 7}
#差集两个集合相减去掉重复项后所剩下的元素
s2-s1
#结果 {5, 6, 7},剩余的元素全部都是集合s2中所有的元素
#如果是s1-s2,则为{1, 2},,剩余的元素全部都是集合s1中所有的元素
#差集是减去共有部分,余下的为差集
超集
当两个集合相同是,互为超集
s3 = {1,2,4,6}
s4 = {1,2,4,6,25,69,54}
#s4是s3的超集[包含s3的全部]
#超集 结果False 判断s4是否被s3包含
s3.issuperset(s4)
#子集 结果True 判断s4是否包含s3
s3.issubset(s4)
#两个集合不相交返回True,有交集就返回False
s3.isdisjoint(s4)
增加元素
s1 = {1,2,3,4}
#增加一个元素
s1.add(5)
#结果 {1,2,3,4,5} add不能传入可变类型,如list
#增加多个元素
s1.update(['A','B','C'])
#结果{'A', 1, 2, 3, 4, 5, 'C', 'B'}
删除元素
#随机删除一个
s1.pop()
#结果{'A', 2, 3, 4, 5, 'C', 'B'},1被随机删除调了
#指定元素删除
s1.remove('C')
#结果{'A', 2, 3, 4, 'B'} 指定删除元素C
字典(dict):
无序的数据集合,通常输出顺序和定义的顺序不一致。
通过键值对/key-value联系起来
字典中的key必须保证唯一,但是value可以重复
使用字典即通过找到其中的key来指向对应的value
字典的每个键值对使用“:”冒号进行分割,多个键值对使用“,”逗号分割。整个字典被一对“{}”包括起来。
字典的定义
d1 = {'name':'瞎子','age':'18','sex':'男'}
#空字典
d = {}
#取值
d1['name']
#结果 瞎子
迭代取值
d1 = {'name':'瞎子','age':'18','sex':'男'}
#枚举取值
for i,value in enumerate(d1):
print('index:{},value:{}'.format(i,value))
#结果
"""
index:0,value:name
index:1,value:age
index:2,value:sex
"""
#取到的值是key值不是value值
#迭代取键值对
d1 = {'name':'瞎子','age':'18','sex':'男'}
#枚举取值
for i,value in d1.items():
print('index:{},value:{}'.format(i,value))
#结果
"""
index:name,value:瞎子
index:age,value:18
index:sex,value:男
"""
字典的嵌套
stuinfo={
'001':{'name':'瞎子','age':'18','sex':'男'},
'002':{'name':'瑞文','age':'22','sex':'男'},
'003':{'name':'EZ','age':'16','sex':'女'},
}
#取值
stuinfo['002']['age']
#结果22
增加
d1 = {'name':'瞎子','age':'18','sex':'男'}
#直接通过新key添加,如果key已经存在则为更改
d1['score'] = 81
#结果{'name': '瞎子', 'age': '18', 'sex': '男', 'score': 81}
#添加多个,将另一个字典中的内容添加到原字典,相同key值的内容被替换,其余内容添加
d2 = {'height':50,'grade':'python'}
d1.update(d2)
#结果{'name': '瞎子', 'age': '18', 'sex': '男', 'score': 81, 'height': 50, 'grade': 'python'}
#直接添加多个
d1.update(phone=138795468,address='LOL召唤师峡谷')
#结果
"""
{'name': '瞎子', 'age': '18', 'sex': '男', 'score': 81, 'height': 50, 'grade': 'python', 'phone': 138795468, 'address': 'LOL召唤师峡谷'}
"""
#setdefault添加
d1.setdefault('birth',2002)
"""
{'name': '瞎子', 'age': '18', 'sex': '男', 'score': 81, 'height': 50, 'grade': 'python', 'phone': 138795468, 'address': 'LOL召唤师峡谷', 'birth': 2002}
"""
#setdefault添加key值,如果key存在,不做修改。如果key不存在,则添加对应的key-value
删除
#指定删除某个键值对,对应的key值
del d1['birth']
d1.pop('birth')
#pop 删除指定的key的key-value
#key存在,则删除,并返回对于的value
#key不存在,报错
#删除最后一个键值对
item = d1.popitem()
#item是被删除的键值对
#清空字典,会得到一个空字典
d1.clear()
查找
#得到key对应的值 '瞎子'
d1.get('name')
#key不存在,默认返回none。如果key不存在,不会报错
#获取字典所有的key值
d1.keys()
#结果 dict_keys(['name', 'age', 'sex', 'score', 'height', 'grade', 'phone'])
#获取字典所有的value值
d1.values()
#结果 dict_values(['瞎子', '18', '男', 81, 50, 'python', 138795468])
#获取所有的key-value值
d1.items()
#结果
"""
dict_items([('name', '瞎子'), ('age', '18'), ('sex', '男'), ('score', 81), ('height', 50), ('grade', 'python'), ('phone', 138795468)])
"""