python去重保留最大值_01 - 数据类型

数据类型

Number(数字)

int(整形)

通常被称为是整型或整数，是正或负整数，不带小数点。

#变量赋值

a = 100

#多个变量的赋值

a = b = 100

float(浮点型)

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)

a = 3.45

bool(布尔)

#内置函数bool(),将其他数据类型转换为bool类型

a = bool("")

b=True

c= False

complex(复数)

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

a = 4+5.6j

b = complex(4,4.5)

类型转换函数

函数

描述

int(x)

将x转换为一个整数

float(x )

将x转换到一个浮点数

ord(x )

将一个字符返回对应的 ASCII 数值

bin()

将十进制转换成二进制

oct(x )

将十进制转换成八进制

hex()

将十进制转换成十六进制

进制表示方式

>>> 0b1010 #0b表示二进制

10

>>> 0o12 #0o表示八进制

10

>>> 0x0A #0x表示十六进制

10

运算符

运算符

描述

&

按位与运算符：都为1,则该位的结果为1,否则为0

|

按位或运算符：有一个为1时，结果位就为1。

^

按位异或运算符：相异时为1。

~

按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1

<<

左移动运算符：由"<

>>

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

%

求余运算

//

整除运算

运算示例

‘‘‘0000 0101 5

0000 1000 8‘‘‘

print(5^8) #13

print(5|8) #13

print(5&8) #0

print(5>>1) #2

print(~100) #-101 加1后取反

注意：%和//运算，如果结果是负数则进行向下圆整。

>>> 10%3

1

>>> 10%-3

-2

>>> 10//3

3

>>> 10//-3

-4

数学函数(math)

函数

描述

abs(x)

返回数字的绝对值，如abs(-10) 返回 10

round(x [,n])

返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

pow(x, y)

x**y 运算后的值。

max(x1, x2,...)

返回给定参数的最大值，参数可以为序列。

min(x1, x2,...)

返回给定参数的最小值，参数可以为序列。

math.ceil(x)

向上取整，如math.ceil(4.1) 返回 5

math.floor(x)

向下取整，如math.floor(4.9)返回 4

math.sqrt(x)

返回数字x的平方根

保留两位小数

#保留两位小数自动四舍五入

a = 2.455

#方案一

b = "%0.2f"%a #字符串

c =float(b)print(c) #结果:2.46#方案二

d = round(a,2) #float

print(d) #结果:2.46

注意：round()如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2。

String(字符串)

str(字符串)

在Python3中，所有的字符串都是Unicode字符串。

u/U:表示unicode字符串 (默认)

r/R:非转义的原始字符串

b:前缀代表的就是bytes

#转换为unicode

a = b‘hello everyone‘.decode("utf-8")print(a) #hello everyone#转换为bytes

b =a.encode("utf-8")print(b) #b‘hello everyone‘

字符串的切片

#切片(顾头不顾尾，步长)

msg=‘hello world‘

print(msg[0:4]) #hell

print(msg[0:4:2]) #hl

print(msg[0:-2]) #hello wor

切片倒置字符串

a = ‘hello everyone‘b= a[::-1]print(b)

注意：步长为正，则从左到右切片，如果起始位置索引大于结束位置索引，则切片为空；步长为负，则从右到左切片，如果起始位置索引小于结束位置索引，则切片为空。

字符串常用操作

方法

描述

find()

mystr.find(str, start, end),检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

count()

mystr.count(str, start, end),返回 str在start和end之间 在 mystr里面出现的次数

replace()

mystr.replace(str1, str2,  2),把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

strip()

移除字符串两边的字符和换行符，默认移除空格

split()

mystr.split(" ", 2)，以空格为分隔符切片 mystr，返回列表

startwith()

str.startwith("a"),判断字符串是否以指定字符为开始,返回布尔值

isdigit()

"123".isdigit(),判断是否由数字组成的字符串，只能判断纯数字的字符串

join()

string.join(seq),以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

List(列表)

方法

描述

len(list)

列表元素个数

max(list)

列表中最大的数

list.count(obj)

列表中统计的对象

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值

list.insert(index, obj)

将元素插入列表

list.pop([index=-1]])

移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

list.remove(obj)

移除列表中某个值的第一个匹配项

list.reverse()

反向列表中元素

list.sort(key=None, reverse=False)

对原列表进行排序

list.clear()清空列表

清空列表

列表去重

#集合，类型是set，没有重复的元素

a = {1, 3, 4, 5, 3, 1, 2, 4}print(a, type(a))#列表去重

a = [1, 3, 4, 5, 3, 1, 2, 4]#方法一

b =[]for i ina:if i not inb:

b.append(i)

b.sort()print(b)#方法二

s =set(a)

c=list(s)print(c)#去重不乱序

d =list(set(a))

d.sort(key=a.index)print(d)

字符串转换为list

a = "dwqrdfqwe"b=list(a)print(b) #[‘d‘, ‘w‘, ‘q‘, ‘r‘, ‘d‘, ‘f‘, ‘q‘, ‘w‘, ‘e‘]

#生成如下列表#[[0,0,0,0,0],[0,1,2,3.4],[0,2,4,6,8],[0,3,6,9,12]]

l=[]for a in range(4):

l1=[]for b in range(5):

l1.append(b*a)

l.append(l1)print(l)

ret= [[i*j for j in range(5)] for i in range(4)]#print(ret)

print(‘-‘*50)

list1= [21,32,12,56,23]#a = sorted(list1,reverse=True)#list1.sort(reverse=True)

list1.reverse() #翻转

print(list1)print(list1.index(21))importrandom

random.shuffle(list1)print(list1)print(‘-‘*50)

l= [1,2,3,4,56,7]

ret= "+".join(str(x) for x inl)print(ret)

案例

元组(tuple)概念

元组就是一个不可变的列表，用于存放多个值，当存放的多个值只有读的需求没有改的需求时用元组最合适。

Dict(字典)

方法

描述

dict.clear()

删除字典内所有元素

dict.get(key, default=None)

返回指定键的值，如果值不在字典中返回默认值

dict.setdefault(key, default=None)

和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值

dict.items()

以列表返回可遍历的(键, 值) 元组数组

dict.keys()

获取字典中的键，需要list()转换

dict.values()

获取字典中的值，需要list()转换

del dict[key]

删除键

dict.pop(key)

返回被删除的value

dict.popitem()

随机返回并删除字典中的一对键和值(一般删除末尾对)

Set(集合)

添加元素

#空集合的创建

a =set()#添加元素

a.update([11,22,33])

a.add(12)print(a) #{33, 11, 12, 22}

删除元素

#删除元素，元素不存在会出异常

a = {33, 11, 12, 22}

a.remove(11)

a.discard(22)#随机删除

a.pop()print(a) #{12}

集合运算

a = set(‘abracadabra‘)print(a) #{‘r‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘}

b = set(‘aadcazam‘)print(b) #{‘m‘, ‘z‘, ‘d‘, ‘c‘, ‘a‘}

#交集，集合a和b共有的元素

print(a & b) #{‘a‘, ‘d‘, ‘c‘}

#集合a中特有的元素

print(a - b) #{{‘r‘, ‘b‘}

#集合b中特有的元素

print(b - a) #{‘m‘, ‘z‘}

#并集，集合a和b中所有的元素

print(a | b) #{‘m‘, ‘r‘, ‘d‘, ‘z‘, ‘c‘, ‘b‘, ‘a‘}

#集合a和b中特有的元素之和，并集-交集

print(a ^ b) #{‘m‘, ‘z‘, ‘r‘, ‘b‘}

集合去重机制

先调用hash,再调用eq,eq不是每次都触发,只有hash值相等的时候才会触发。

可变类型和不可变类型

不可变类型

Number(数字)、String(字符串)、Tuple(元组)

注意：int()整数在 [-5, 257) 常驻内存，这些整数对象是提前建立好的，不会被垃圾回收。(id相同)

判断数据类型

isinstance 和 type 的区别在于：isinstance(10，int) type(10)

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。