运算符

一.算数运算：

二.比较运算：

三.赋值运算

四.逻辑运算

五.成员运算

基本数据类型

一.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。