运算符
一.算数运算：
二.比较运算：
三.赋值运算
四.逻辑运算
五.成员运算
基本数据类型
一.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))
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
age99brain 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。
扫一扫
1718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
