Python学习：4.运算符以及数据类型解析

时间：2024-01-21 12:10:12

运算符

一.算数运算：

二.比较运算：

三.赋值运算

四.逻辑运算

 五.成员运算

 

基本数据类型

一.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.字符串的常用功能

  • 分割
  • 长度
  • 索引
  • 切片
#字符串分割
>>> 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
View Code

3.字符串特有功能

  • 去除两边空白
  • 是否以什么开头
  • 查找子序列
  • 将字符串的某个子序列替换为指定的值
  • 变大写
  • 判断字符串是否和某个字符串一样
#移除两边空白，无参数时移除两侧空格，换行符
>>> 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())
View Code

四.列表（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.列表特有功能

  • 排序
  • 追加
  • 插入
  • 移除
  • 个数
  • 扩展
  • 反转
#排序
#此函数方法对列表内容进行正向排序，排序后的新列表会覆盖原列表，也就是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']
View Code

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）就是相应值的索引，相当于自定义了每个指的索引。

  • 索引
  • 新增
  • 删除
  • 键、值、键值对
  • 长度
#通过索引拿到值
>>> 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}
View Code

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。

相关文章