3 python --运算符和数据类型

运算符

算数运算

比较运算

赋值运算

逻辑运算

 

 数据类型

常用的数据类型：数字（整形，长整型，浮点型，复数），字符串，列表，元组，字典，集合

1整形

整数类型的范围是2**32，其中包含正数和负数（2的31次方个正和2的31次方的个负数）

PS:查看一个数据的类型使用type(数据)方法

#int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#long（长整型）
注意：在Python3里不再有long类型了，全都是int
>>> a= 2**64
>>> type(a)  #type()是查看数据类型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>

#complex复数型
>>> x=1-2j
>>> x.imag
-2.0
>>> x.real
1.0

其他数据类型（了解部分）

 

2浮点型

浮点类型就是带小数点的，多余的位数会四舍五入

a=2.5555
b=1.545
type(a)
float #float代表浮点数
print(round(a,2))
print(round(b,2))
#round(float,2)
#小数点精确的最后一位必须为偶数

 3字符串

name = 'alex' #str类的对象
v = name.capitalize() #首字母大写
print(v)

name = 'AleX'
v = name.casefold() #转换成小写，应用更广，英文、德语等
v = name.lower() #转换小写，主要是英文，跟upper()相反
print(v)
name ='alex'
v =name.center(20,'*')
print(v)
name = "aniefnaodoiwjcaanoenfaiw"
v = name.count('a',12,15)
#计算传入参数的个数
# 起始位置（索引）
# 结束位置（索引）
print(v)

name = 'alex'
# 是否以ex结尾
v1 = name.endswith('ex')
print(v1)
# 是否以al开头
v2 = name.startswith('al')
print(v2)

找到制表符\t，进行替换（包含前面的值）
name = "a1\te\tx\nalex\tuu\tkkk"
v = name.expandtabs(20) #\t的tab变成20倍
print(v)

找到指定子序列的索引位置，不存在返回-1
name = 'alex'
v = name.find('l')  #
print(v)
找索引，不存在则报错
v = name.index('a')

name = '我是%s,xxxx' %a
tp1 = "我是:{0};年龄:{2};性别:{1}"
v= tp1.format('李杰',19,'都行')
# v = tp1.format("alex",19,'ok')
print(v)

tp1 = "我是:{name};年龄:{age};性别:{gender}"
v = tp1.format(name='alex',age=19,gender='any')
print(v)

tp1 = "我是:{name};年龄:{age};性别:{gender}"
# v = tp1.format_map('name'='alex','age'=19,'gender'='any')
v = tp1.format_map({'name':'alex', 'age':19, 'gender':'any'}) #在format_map中传入的为字典形式
print(v)


name = 'alex8好'
v = name.isalnum()  #判断是否是字母字数汉字，不能包含特殊字符
print(v)
v2 = name.isalpha()
print(v2)

判断是否是数字
num = '123'
v1 =num.isdecimal() #123
v2 =num.isdigit() #123，②
v3 =num.isnumeric() 　#123 ，二，②
print(v1,v2,v3)

n ='class'
v =n.isidentifier()
print(v)

是否全部是小写或大写
name = 'ALEx'
v = name.isupper() #islower()
print(v)


全部转换成大写（小写） 比如验证码
name = 'alex'
v = name.upper() #name.lower()
print(v)

是否包含隐含的字符类
name = "钓鱼要钓刀鱼，\n刀鱼要到岛上钓"
v =name.isprintable()
print(v)


是否全部是空格
name ='alex'
v = name.isspace()
print(v)


元素拼接(元素字符串) ***** 必须会
name = 'alex'
# v = "_".join(name) #内部循环每个元素
# print(v) #打印结果  a_l_e_x
for i in ['海峰','杠娘','李杰']:
    print(i)
name_list = ['海峰','杠娘','李杰']  #元素只能是字符串，不能是数字
v = "搞".join(name_list)
print(v)


左右填充
center,rjust,ljust
name ='alex'
v = name.ljust(20,'*')
print(v)

对应关系 + 翻译
name = 'anwoidwoidhawoidhwaoihofeiowiiejaoiej'
m = str.maketrans('aeiou','12345') #对应关系
v = name.translate(m)
print(v)


分割，保留分割的元素  应用：计算器
content = '李泉SB刘康'
v = content.split('SB')
v = content.partition('SB')
print(v)

替换
content = '李泉SB刘康SB刘浩SB打好'
v = content.replace('SB',"love",1)  #替换次数为1
print(v)

可指定分割符
name ='alex\n'
v = name.strip() #去除空白, \t,\n
print(v)


大小写转换
name = 'Alex'
v =name.swapcase()
print(v)

填充0的个数
name = 'alex'
v =name.zfill(20)
print(v)


v1 = 'alex'
v2 = 'eric'
v = v1 + v2 #执行v1的__add__功能
print(v)

字符串功能总结：(常用）
name = 'alex'
name.upper()
name.lower()
name.split()
name.find()
name.strip()
name.startswith()
name.format()
name.replace()
'alex'.join(['a','bb'])
####额外功能：
name[0]
name[0:3]
name[0:3:2]
len(name)
for循环,每个元素是一个字符

4列表

列表由一系统按特定顺序排列的元素组成，在python中用[]表示列表，并用逗号分隔中间的元素

执行功能；
1.追加
user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.append('刘铭')
print(user_list)
2. 清空
user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.clear()
print(user_list)

3. 拷贝(浅拷贝)
user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
v = user_list.copy()
print(v)
print(user_list)

4. 计数
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.count('李泉')
print(v)

5. 扩展原列表
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.extend(['郭少龙','郭少霞'])
print(user_list)


6. 查找元素索引，没有则报错
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.index('小龙')
print(v)

7. 删除并且获取元素 - 索引
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.pop(1) #删除索引位置1的内容
print(v)
print(user_list)

8. 删除 - 值
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.remove('刘一')
print(user_list)

9. 翻转
user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.reverse()
print(user_list)

sort排序 直接修改原内容
nums = [11,22,3,4,7,8]
print(nums)
v1 = nums.sort()
print(nums) #排序从小到大
nums.sort(reverse=True)  #排序从大到小
print(nums)


for i in range(10,0,-1): #倒序
    print(i)

li = ['eric','alex','tony']
for i in range(0,len(li)):
    ele = li[i]
    print(ele)

li = ['eric','alex','tony']
for i,ele in enumerate(li,1): #默认i从0开始，写上1则从1开始
    print(i,ele)

v = input('请输入商品序列号：')
v = int(v)
item = li[v-1]
print(item)

5元组

不能修改的值称为不可变的，不可变的列表称为元组，在python中用()来标识

####元组:tuple  *** 不可被修改的列表，不可变类型
user_tuple=('alex','eric','seven','alex')
# v = user_tuple[0]
#计数
v = user_tuple.count('alex')
print(v)
#获取值的第一个索引位置
v = user_tuple.index('eric')
print(v)

###额外
for i in user_tuple:
    print(i)
v = user_tuple[0:2]
print(v)


user_tuple=('alex','eric','seven',['chentai','liuhao','james'],'alex') #元组整体不能被修改，元组内的列表可以修改
user_tuple[3][1]='kobe'
print(user_tuple)

user_tuple=['alex','eric','seven',('chentai','liuhao','james'),'alex']
user_tuple[3]='abc'
print(user_tuple)
#####元组最后，加逗号 (pay attention)
li = ('alex',)
print(li)

6字典

一系列的键值对称为字典，在python中用{}来标识，一个键值，一个有效值，key-value形式表示

#####字典：dict
dic = {'k1':'v1','k2':'v2'}
#清空
dic.clear()

#浅拷贝
v = dic.copy()

#效果相同，但是get不会报错，默认返回值None(111)
v = dic.get('k1',111)
v =dic['k1']

#删除并获取对应的value值
v =dic.pop('k1')

#随机删除键值对，并获取到删除的键值
k,v =dic.popitem() #('k2':'v2')

#增加，如果主键存在则不增加
dic.setdefault('k3','v3')
print(dic)
dic.setdefault('k2','111')
print(dic)

#批量增加或修改
dic.update({'k3':'v3','k1':'v24'})
print(dic)

print(v)

dic = dic.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'ahsiwhi'
print(dic)

dic =dic.fromkeys(['k1','k2','k3'],[1,])
{
   k1:123123, #[1,2]
   k2:123123, #[1,]
   k3:123123      #fromkeys在生成字典的时候，k1、k2、k3对应的内存地址相同，k1对应的value改变，其他的也跟着改变
dic['k1'].append(222)
print(dic)

#####额外：
字典可以嵌套
字典key 必须是不可变类型(元组）
dic = {
    'k1':'v1',
    'k2':[1,2,3],
    (1,2):'111',
    True:'11a',
    1:'a',
    False:'abc'
}
print(dic)

key
   不可变
   True,1

7集合

包含多个元素，中间用逗号(,)分割，标识为{}，自带去重功能

主要遵循三个原则

1每个元素必须是不可变类型(可hash,可作为字典的key)

2没有重复的元素

3无序

#####set:集合
s1 = {'alex','eric','tony','kobe','kobe23'}
s2 = {'alex','eric','tony','jame'}
v = s1.difference(s2) #s1中有s2中没有
print(v)

v = s2.difference(s1) #s2存在s1不存在
print(v)

v = s1.symmetric_difference(s2) #差集，取两者中的不同
print(v)

v= s1.intersection(s2) #交集
v=s1.union(s2) #并集

####s1中存在，s2中不存在，然后对s1情况，然后在重新赋值
v = s1.difference_update(s2)
s1.discard('alex') #移除
s1.update({'alex','123123','fff'}) #更新增加

print(s1)


####额外的
v=s1[0] #不支持索引取值
print(v)
s1 = {'alex','eric',(1,2,3)} #集合里只能有元组，不支持列表，集合
for i in s1:
    print(i)

数据类型总结

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

 

 

按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

 

 

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

 

 

 

帮助查看

help(sorted)

类型转换 通过运用类型转换的函数，直接转换

1 十六进制转换十进制  int()函数

In:int('a',16)  //base是16，意思'a'是一个16进制的字符串

Out:10

 2十进制转换十六进制  hex()函数

In:hex(12)

Out:'0xc'

3字符串转换十进制  int()

In:hex(10)

Out:'0xa'

In:eval(hex(10))

Out:10

4字典转换成列表  dic.items()

In:dic={'a':1,'b':2}

In:dic.items()

Out:[('a',1),('b',2)]

5列表转换成字典  dict(list)

#列表必须由两个元素的列表或元组组成

In:l1=dic.items()

In:dict(l1)

Out:{'a':1,'b':2}

In:l2=['abc',123,('c',60)]

In:dict(l2)

6将纯数字的字符串或数字转换成长整型  long()   #在python3中取消了long ，将long的功能整合在了int内

In:help(long)

In:long(12)

Out:12L

7 将纯数字的字符串或者数字转换成浮点数  float()

In:help(float)

In:float(12)

Out:12.0

In:float('12.0')

Out:12.0

8把数字转换成复数  complex()

In:complex(10)

Out:(10+0j)

In:complex('10')

OutL:(10+0k)

9把对象转换成字符串  str()

In:str(12)

Out:'12'

In:str('abc')

Out:'abc'

In:str(('a',1))

Out:"('a',1)"

In:str([range(5)])

Out:[[0, 1, 2, 3, 4]]

In:print(str({'x':1,'y':2}))

Out:{'y': 2, 'x': 1}

10把可迭代对象转换成列表

In:list('abc')

Out:['a','b','c']

In:list((1,2,3))

Out:[1,2,3]

11把可迭代对象转换成元组

In:tuple('123')

Out:('1', '2', '3')

In:tuple(range(5))

Out:(0,1,2,3,4)