Python学习:4.数据类型以及运算符详解编程语言

运算符

一.算数运算:

Python学习:4.数据类型以及运算符详解编程语言

二.比较运算:

Python学习:4.数据类型以及运算符详解编程语言

三.赋值运算

Python学习:4.数据类型以及运算符详解编程语言

四.逻辑运算

Python学习:4.数据类型以及运算符详解编程语言

 五.成员运算

Python学习:4.数据类型以及运算符详解编程语言 

基本数据类型

一.Number(数字)

Python3中支持int、float、bool、complex。

使用内置的type()函数查询变量类型。

>>> a,b,c,d = 1,2.0,True,3+4j 
>>> print(type(a),type(b),type(c),type(d)) 
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

int(整型)

在python2中整数类型有两种一个是int,表示整型,一种是long,表示长整型。而在python3中整数类型只有int,没有限制大小,但是由于内存有限得原因,所以我们使用的整型不可能是无限大的。

在python2中整型大小的限制

在32为系统上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647

在64为系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807

python2中,当没有超过这个范围的时候是int类型,当超过这个范围的时候就是long类型。

 

整型的表现形式有四种,分别是二进制(0b开头),八进制(0o开头),十进制,十六进制(0x开头),进制之间的转换可以使用python中的内置函数(bin、oct、int、hex)。

#10进制转2进制 
>>> bin(32) 
'0b100000' 
 
#10进制转8进制 
>>> oct(32) 
'0o40' 
 
#10进制转16进制 
>>> hex(32) 
'0x20' 
 
#2进制转10进制 
>>> int('0b00100000',2) 
32 
 
#2进制转8进制 
>>> oct(0b00100000) 
'0o40' 
 
#2进制转16进制 
>>> hex(0b00100000) 
'0x20' 
 
#8进制转10进制 
>>> int('0o40',8) 
32 
 
#8进制转2进制 
>>> bin(0o40) 
'0b100000' 
 
#8进制转16进制 
>>> hex(0o40) 
'0x20' 
 
#16进制转10进制 
>>> int('0x20',16) 
32 
 
#16进制转2进制 
>>> bin(0x20) 
'0b100000' 
 
#16进制转8进制 
>>> oct(0x20) 
'0o40'

二.布尔值

布尔值很简单,就是真和假,1为真0为假(进行判断的时候除了数字0为假,其它数字都为真)

三.字符串(str)

1.字符串的创建

我们的第一串代码hello world就是字符串类型的。

a = 'hello world'

Python中的字符串通常使用单引号(‘’)或者双引号(“”)括起来,在字符串中可以使用反斜杠(/)进行转义,可以使用+好将两个字符串连接起来。

>>> a = 'alexsel' 
>>> b = "ld000001" 
>>> c = a + b 
>>> print(a,b,c) 
alexsel ld000001 alexselld000001

2.字符串的常用功能

  • 分割
  • 长度
  • 索引
  • 切片
Python学习:4.数据类型以及运算符详解编程语言

#字符串分割 
>>> aa="alexsel and alenten" 
>>> print(aa.split("al")) 
['', 'exsel and ', 'enten'] 
>>> aa="alexandalenten" 
>>> print(aa.split("e")) 
['al', 'xandal', 'nt', 'n'] 
""" 
检索到规定字符删除并在那个地方进行分割,在这是检索字符串里的每一个而不是第一个,如果只需对第一个进行分割,只需在自己所规定的检索字符串后加上一个1(最多分割1次) 
aa.rsplit从右向左检索 
""" 
#字符串长度 
>>> a = 'alexsel' 
>>> a.__len__() 
7 
>>> len(a) 
7 
#索引 
>>> a = 'alexsel' 
>>> a[3] 
'x' 
>>> az="alex,ala" 
>>> print(az.capitalize())#首字母变为大写这个括号里没有就是无参数 
Alex,ala 
>>> al="alex" 
>>> ret =al.count("l") #检索在al这个整个字符串里i出现了多少次 
>>> print(ret) 
1 
#切片 
>>> a = 'alexsel' 
>>> a[0:2]    #拿到索引大于等于0小于2的字符,索引从零开始 
'al' 
#字母小写变大写,大写变小写 
>>> aa=" a sdf  AAA" 
>>> print(aa.swapcase() 
A SDF  aaa 
#判断是否全为数字 
... lj="666" 
>>> print(lj.isdigit()) 
True 
>>> lj="5s55s" 
>>> print(lj.isdigit()) 
False 
>>> lj="aaa" 
>>> print(lj.isdigit()) 
False 
#判断字符串是否为字母 
... aa="8a8a8a" 
>>> print(aa.isalpha())#F 
False 
>>> aa="aaa" 
>>> print(aa.isalpha())#T 
True 
>>> aa="111" 
>>> print(aa.isalpha())#F 
False 
#判断字符串是否只包含字母和数字 
... lj="sdfasdfsd" 
>>> print(lj.isalnum())#T 
True 
>>> lj="Ssss" 
>>> print(lj.isalnum())#T 
True 
>>> lj="555555" 
>>> print(lj.isalnum())#T 
True 
>>> lj="!aaa" 
>>> print(lj.isalnum())#F 
False 
#判断字符串是否为空格 
... lj="  " 
>>> print(lj.isspace())#T 
True 
>>> lj="Ssss" 
>>> print(lj.isspace())#F 
False 
>>> lj="/t" 
>>> print(lj.isspace())#T 
True 
>>> lj="/n" 
>>> print(lj.isspace())#T 
True

3.字符串特有功能

  • 去除两边空白
  • 是否以什么开头
  • 查找子序列
  • 将字符串的某个子序列替换为指定的值
  • 变大写
  • 判断字符串是否和某个字符串一样
Python学习:4.数据类型以及运算符详解编程语言

#移除两边空白,无参数时移除两侧空格,换行符 
>>> aa=" a sdf  " 
>>> print(aa.strip()) 
a sdf 
>>> #有参数时移除两侧指定的字符 
... bb = "**aaa**" 
>>> print(aa.strip('*')) 
a sdf 
#是否以什么开头 
>>> aa = "Alexsel" 
>>> aa.startswith("A") 
True 
#查找子序列 
>>> a="jjfjjmldhzf" 
>>> print(a.find("f")) #找到变量a这个字符串中的第一个f的索引 
2 
>>> print(a.find("j")) 
0 
>>> print(a.find("a"))#如果没有找到就返回-1 
-1 
>>> print(a.find("dhzf"))#返回的是第一个字符的索引 
7 
#变大写 
>>> aa = "alexsel" 
>>> print(aa.upper()) 
ALEXSEL 
#is 
#判断字符串是否为字母 
... aa="8a8a8a" 
>>> print(aa.isalpha()) 
False 
>>> aa="aaa" 
>>> print(aa.isalpha()) 
True 
>>> aa="111" 
>>> print(aa.isalpha()) 
False 
>>> 
>>> #判断是否为数字 
... lj="666" 
>>> print(lj.isdigit()) 
True 
>>> lj="5s55s" 
>>> print(lj.isdigit()) 
False 
>>> lj="aaa" 
>>> print(lj.isdigit()) 
False 
#判断是否全为小写字母 
... lj="sdfasdfsd" 
>>> print(lj.islower()) 
True 
>>> lj="Ssss" 
>>> print(lj.islower()) 
False 
>>> lj="555555" 
>>> print(lj.islower()) 
False 
>>> 
#判断字符串是否只包含字母和数字 
... lj="sdfasdfsd" 
>>> print(lj.isalnum()) 
True 
>>> lj="Ssss" 
>>> print(lj.isalnum()) 
True 
>>> lj="555555" 
>>> print(lj.isalnum()) 
True 
>>> lj="!aaa" 
>>> print(lj.isalnum()) 
False 
>>> 
#判断字符串是否为空格 
lj="  " 
print(lj.isspace()) 
lj="Ssss" 
print(lj.isspace()) 
lj="/t" 
print(lj.isspace()) 
lj="/n" 
print(lj.isspace())

四.列表(List)

Python最常用的数据类型就是列表,在列表中的的数据类型可以不同,而且可以多层嵌套数据。

列表的格式,列表是写在[]中,使用逗号(,)进行元素间的分割。

1.创建列表

li=[11,22,33] 
li=list()#创建一个空的列表 
li=list([11,22,33)]

2、转换

字符串、字典、元组都可以转换为列表

>>> s1 = '李璐' 
>>> li = list(s1) 
>>> print(li) 
['', ''] 
#s1可以是可迭代的数据,而且在转换时自动迭代转换为列表将循环的每一个元素,当作列表的元素 
#元组转换为列表 
>>> dic=("k1",123123,"alex",123) 
>>> li = list(dic) 
>>> print(li) 
['k1', 123123, 'alex', 123] 
#字典转换为列表 
>>> dic = {'k1':123,'k2':'alexsel','k3':'buff'} 
>>> li = list(dic) 
>>> print(li)#只输出key(键),字典默认循环时,循环的就是key 
['k1', 'k2', 'k3'] 
>>> ll = list(dic.values())#dic.values,获取dic的键的值 
>>> print(ll) 
[123, 'alexsel', 'buff'] 
>>> lo = list(dic.items())#dic.items,获取dic的键值对 
>>> print(lo) 
[('k1', 123), ('k2', 'alexsel'), ('k3', 'buff')]

3.列表常用功能

  • 索引
  • 切片
  • 长度
  • ……
name_list=["alex","brain","rain"] 
#索引 
>>>print(name_list[0])#输出第一个字符串 
alexsel 
#切片 
>>>print(name_list[0:2])#输出索引为0,1的字符串 
['alex', 'brain'] 
#len 
>>>print(name_list[2:len(name_list)])#在这里是输出序号为2的字符串 
['rain']

4.列表特有功能

  • 排序
  • 追加
  • 插入
  • 移除
  • 个数
  • 扩展
  • 反转
Python学习:4.数据类型以及运算符详解编程语言

#排序 
#此函数方法对列表内容进行正向排序,排序后的新列表会覆盖原列表,也就是sort排序方法是#直接修改原列表list排序方法。 
l=[4,2,3,1] 
l.sort() 
print(l)    # [1,2,3,4] 
#追加 
... name=["asdf","asdfsdf","sssdfs"] 
>>> name.append("lslslslsl") 
>>> print(name) 
['asdf', 'asdfsdf', 'sssdfs', 'lslslslsl'] 
#在最后追加一个字符串 
#插入 
>>> name=["asdf","asdfsdf","sssdfs"] 
>>> print(name.index("sssdfs")) 
2 
>>> name.insert(name.index("asdf"),"aaa") 
>>> print(name) 
['aaa', 'asdf', 'asdfsdf', 'sssdfs'] 
>>> name.insert(2,"aaa") 
>>> print(name) 
['aaa', 'asdf', 'aaa', 'asdfsdf', 'sssdfs'] 
>>> #在相应索引号(序号)插入字符串,序号在前,字符串在后name.index(1,'aaa') 
#移除 
>>> name=["asdf","asdfsdf","sssdfs"] 
>>> ai=name.pop(0) 
>>> print(name) 
['asdfsdf', 'sssdfs'] 
>>> print(ai) 
asdf 
>>> ai=name.pop() 
>>> print(name) 
['asdfsdf'] 
>>> print(ai) 
sssdfs 
#移除相应序号的字符串,如果不加序号就移除最后1个字符串 
#而且在执行移除命令时还可以把移除的字符串赋值给其它的变量 
#个数统计 
>>> name=["asdf","asdfsdf","sssdfs"] 
>>> print(name.count("asdf")) 
1 
#统计匹配的字符串有多少个,最小匹配单位为一个字符串不是字符 
#扩展字符串内容 
>>> name=["asdf","asdfsdf","sssdfs"] 
>>> name.append("lslslslsl")#将sssdfs字符串作为最后一个元素扩充到name里面 
>>> print(name) 
['asdf', 'asdfsdf', 'sssdfs', 'lslslslsl'] 
>>> print(name.count("asdf")) 
1 
>>> kali=[111,555,999] 
>>> name.extend(kali)#扩充,将kali里的元素(迭代的)添加到name中,依次添加在后面 
>>> print(name) 
['asdf', 'asdfsdf', 'sssdfs', 'lslslslsl', 111, 555, 999] 
#对字符串的内容进行倒置,反转 
>>> name=["asdf","asdfsdf","sssdfs"] 
>>> name.reverse() 
>>> print(name)#将元素的位置反转 
['sssdfs', 'asdfsdf', 'asdf']

5.嵌套

>>> li=["alex",123,{"k1":"v1","k2":{"vv":("zzz",22,333),"ii":444}}] >>> zz=li[2]       #将li中索引为2的元素赋值给zz >>> aa=zz.get("k2") #将字典zz的key为k2的值赋给aa >>> aal=aa.get("vv")    #将字典aa中key为vv的值赋值给aal >>> aaa=aal[2]    #将aal中索引为2的元素赋值给aaa >>> print(li[2]["k2"]["vv"][2]) 333 >>> print(aaa) 333

 

五、元组(tuple)

元组合列表类似,但是元组中的元素一旦定义了就不能就行修改。

元祖的格式,元祖使用一个括号括起来,元素之间的分割是用逗号(,),元组中也可以存放不同类型的数据。

1.创建元组

t=(11,22,33) 
t=tuple((11,22,33))

2.转换

字符串、列表以及字典都可以转换为元组

>>> name = 'alexsel' 
>>> li = ['all',123] 
>>> dic = {'k1':'alic','k2':'naan'} 
>>> print(tuple(name))#输出的时候将字符串单个字符作为一个元素迭代输出 
('a', 'l', 'e', 'x', 's', 'e', 'l') 
>>> print(li) 
['all', 123] 
>>> print(tuple(dic),tuple(dic.values()),tuple(dic.items())) 
('k1', 'k2') ('alic', 'naan') (('k1', 'alic'), ('k2', 'naan')) 
#这里字典的输出规则和列表的一样

3.常用功能

  • 索引
  • 长度
  • 切片
>>> name_sss=("liudi","balabala","bulabula") 
#索引输出 
>>> print(name_sss[0]) 
liudi 
#len 
>>> print(name_sss[len(name_sss)-1])#输出索引数为长度减一的元素,就是最后一个元素 
bulabula 
#切片 
>>> print(name_sss[0:1]) 
('liudi',)

4.元组特有功能

  • 个数
  • 索引位置
>>> tup = ('alexsel',123123,'uuuttt') 
#检索个数 
>>> print(tup.count('alex'))    #最小匹配单位是一个元素 
0 
>>> print(tup.count('alexsel')) 
1 
#返回某个元素的索引 
>>> print(tup.index(123123)) 
1 
>>> print(tup.index('uuuttt'))

5.嵌套

t=(11,22,33) 
t=((11,22,33)) 
t=(11,22,["alex",{"k1":"v1"}])

6.元组的特性

元组的特性是不可修改,元素不可修改,但是元素中包含的元素可以修改

>>> t=(11,22,["alexsel",{"k1":"k2"}]) 
>>> print(t) 
(11, 22, ['alexsel', {'k1': 'k2'}]) 
>>> t[2].append("sss") #对元组中的列表里添加元素 
>>> print(t) 
(11, 22, ['alexsel', {'k1': 'k2'}, 'sss']) 
>>> t[2][1].setdefault("k2","v3") #或用update或t[2][1]["k3"]=123,添加键值对 
'v3' 
>>> print(t) 
(11, 22, ['alexsel', {'k1': 'k2', 'k2': 'v3'}, 'sss']) 
>>>

六、字典

Python中一个比较特别的数据类型,字典中的数据是映射的关系,一个键(key)映射一个或多个值(value),使用{}来进行标识,字典是一个无序的键值对的集合,而且一个字典中的间(key)是唯一的,不能重复。

1.创建字典

>>> a={"k1":123} 
>>> b = dict(k3=123,k2=456) 
>>> print(a) 
{'k1': 123} 
>>> print(b) 
{'k3': 123, 'k2': 456}

用列表创建字典时不能直接加到字典里需要通过enumerate。

>>> le=[11,22,44] 
# dic=dict[le]  #使用这个会报错 
>>>dictea=dict(enumerate(le)) #需要通过enumerate拿到每个元素的索引 
>>> print(dictea)  #然后将索引作为key,le中的元素作为值创建字典 
{0: 11, 1: 22, 2: 44}

2.字典常用功能

字典中没有切片,因为字典中的键值对的键(key)就是相应值的索引,相当于自定义了每个指的索引。

  • 索引
  • 新增
  • 删除
  • 键、值、键值对
  • 长度
Python学习:4.数据类型以及运算符详解编程语言

#通过索引拿到值 
>>> user={"name":"zz","age":99,"brain":0} 
>>> print(user["name"]) 
zz 
#通过for循环输出键,值 
>>> 
>>> user={"name":"zz","age":99,"brain":0} 
>>> for i in user:  # i 拿到的是key,通过 i 拿到值 
...     print(i,user[i]) 
... 
name zz 
age 99 
brain 0 
#通过get拿到相应key的值 
>>> user={"name":"zz","age":99,"brain":0} 
>>> val=user.get("age") 
>>> print(val) 
99 
>>> val=user.get("age11") #没哟这个键,所以输出None 
>>> print(val) 
None 
>>> val=user.get("age") 
>>> print(val) 
99 
>>> val=user.get("age11",99)#如果不存在在后面加上值就可以赋值给值 
>>> print(val) 
99 
>>> val=user.get("age11","ooo")#如果不存在在后面加上值就可以赋值给值 
>>> print(val) 
ooo 
>>> print(val) 
ooo 
#删除 
>>> user={"name":"zz","age":99,"brain":0} 
>>> print(user.pop("name"))#输出所删除的键值对的值 
zz 
>>> print(user)#输出字典 
{'age': 99, 'brain': 0} 
>>> user={"name":"zz","age":99,"brain":0} 
>>> print(user.popitem())#输出所删除的字符(无参数就从最后一个参数开始删除) 
('brain', 0)  #删除的是一个元素,所以输出的时候就输出键和值 
>>> print(user)#输出字典的内容 
{'name': 'zz', 'age': 99} 
#新增 
>>> user={"name":"zz","age":99,"brain":0} 
>>> print(user) 
{'name': 'zz', 'age': 99, 'brain': 0} 
>>> item={"a1":123,"a2":456} 
>>> user.update(item)#将item的字典更新(链接到user后面) 
>>> print(user) 
{'name': 'zz', 'age': 99, 'brain': 0, 'a1': 123, 'a2': 456}

3.另一种方式创建字典

示例一

>>> a1 = {"keys":1111} 
>>> aa = a1.fromkeys(["key","keys2"], 123) 
>>> print(aa)#结果{'key': 123, 'keys2': 123} 
{'key': 123, 'keys2': 123} 
>>> n=dict.fromkeys(["k1","k2","k3"],[]) 
>>> print(n) 
{'k1': [], 'k2': [], 'k3': []} 
""" 
用这个方法创建的字典在对键追加值时,会对所有的键进行追加,因为他们在内存里公用一个[],而不用这个方法创建时就不会出现这个情况 
"""

示例二

>>> n["k1"].append("s")  #append在后面追加一个参数 
>>> n["k2"]=456 
>>> print(n) 
{'k1': ['s', 's'], 'k2': 456, 'k3': ['s', 's']} 
>>> 
>>> n2={"k1":[],"k2":[],"k3":[]} 
>>> print(n2) 
{'k1': [], 'k2': [], 'k3': []} 
>>> n2["k1"].append("s") 
>>> print(n2) 
{'k1': ['s'], 'k2': [], 'k3': []}      #不使用fromkeys创建的时候不会出现对每一个键都追加

 

今天python的数据类型的介绍就到这里了,终于可以睡个安稳觉了,明天继续。

人生苦短,我用Python。

原创文章,作者:Maggie-Hunter,如若转载,请注明出处:https://blog.ytso.com/12362.html

(0)
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论