Python核心数据类型

数据类型
number
判断奇偶

number_进制

bool

range

序列
序列互转

序列解包

序列_字符串
字符串方法

屏蔽敏感词案例

序列_列表
列表方法

列表推导式

序列_元组

映射类型_字典
字典方法

字典应用

集合

数据类型

number

python中有几种数字类型,它们分别是

int(整数型)

float(浮点数型)

complex(复数型)

还有布尔类型也算数字

type() 这个内置函数可以查看值的类型

>>> type(1)
<class 'int'>
>>> type(1.1)
<class 'float'>
>>> type(1.1j)
<class 'complex'>

# 布尔就不写了

其中复数型在平时开发的时候基本用不到,一般会在科学计算等场景可能会用到复数型

平时用的最多的还是int和float

以及

python3中移除了长整形long

原来长整形的部分并入了int类型

In[8]: 2**1000
Out[8]: 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

In[9]: type(2**1000)
Out[9]: int

python中整型和浮点型进行运算,那么结果一定是浮点型

In[11]: 1-1.0
Out[11]: 0.0

需要注意的是 在python3中,

/是浮点除法

//是整型除法

>>> type(2/2)
<class 'float'>

>>> type(2//2)
<class 'int'>

在除法上2和3还是有一些区别的

int和float是可以互相转换的

In[17]: int(1.0)
Out[17]: 1

In[18]: float(int(1.0))
Out[18]: 1.0

判断奇偶

def jo(num):
if num%2==0:
print("偶数")
else:
print("奇数")

number_进制

Python中

二进制以0b开头

八进制以0o开头

十六进制以0x开头

a = 0b1010
b = 0o12
c = 0xa
d = 10

print(a)
print(b)
print(c)
print(d)
# 最后会打印4个10

进制之间是可以通过int() hex() bin() oct() 来互相转换的

不过有一些区别

In[12]: type(int(0b10110))
Out[12]: int

In[13]: type(hex(0b10110))
Out[13]: str

In[14]: type(oct(0b10110))
Out[14]: str

In[14]: type(bin(0x10110))
Out[16]: str

int类型有一个方法 bit_length()

|  bit_length(...)
|      int.bit_length() -> int
|
|      Number of bits necessary to represent self in binary.
|      >>> bin(37)
|      '0b100101'
|      >>> (37).bit_length()
|      6

可以理解为数字转换成2进制后的位数

37转换成二进制后是0b100101 有6个数字

所有(37).bit_length() 的返回结果是6

这个方法要注意的是

In [35]: 37.bit_length()
File "<ipython-input-35-e161a0e3ca9c>", line 1
37.bit_length()
^
SyntaxError: invalid syntax

In [36]: (37).bit_length()
Out[36]: 6

In [38]: a = 11
In [39]: a.bit_length()
Out[39]: 4

bool

>
4000
>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

python中这两个单词是要首字母大写的

布尔类型和int/float互转

>>> int(True)
1
>>> float(True)
1.0
>>> int(False)
0
>>> float(False)
0.0

python中除了一些空值之外,其他非空类型转换为布尔值得到的值都是True

>>> bool('')
False
>>> bool(())
False
>>> bool({})
False
>>> bool([])
False
>>> bool(0)
False
>>> bool(None)
False

# 但是bool('0')是True

range

py3中

In [76]: range(10)
Out[76]: range(0, 10)

In [77]: type(_)
Out[77]: range

而在py27中

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(range(10))
<type 'list'>

range方法的前两个参数确定数字的范围,而第三个参数step确定步长

也就是每隔step-1拿一个数

>>> range(1,10,2)
[1, 3, 5, 7, 9]

py27中的xrange等价于py3的range

如果想倒着来的话 range(end,start,-1)

序列

序列可以通过索引来访问对应的元素

在python中有3种内置序列

字符串

列表

元组

它们共同的特点

1. 可以使用成员操作符(in/not in)来判断元素是否在序列中

2. 通过索引获取一个元素

3. 通过切片获取一组元素

4. *一个数字 可以让数组中的元素重复n次

5. 同类型的序列可以通过+来进行拼接

6. 通过len()获取序列长度

7. 序列都是可迭代对象

还有比较重要的一点:索引如果超过范围就会报错

所以python没有办法用js这种在数组末尾追加元素的方法

// js中可用
arr[arr.length] = value

# python中用会报错
list[len(list)] = value
# 不过python可以这样
list[len(list):] = [value1,[value2,...]]

# 比如
In [13]: a = [1,2,3]
In [16]: a[len(a):] = [4]

In [17]: a[len(a):] = [5,6]

In [18]: a
Out[18]: [1, 2, 3, 4, 5, 6]

下面用一个字符串做演示一些序列的操作

a = "abcdefg"

print("a" in a)     # True

print(a[2])         # c

print(a[1:4])       # bcd
print(a[2:])        # cdefg
print(a[:-2])       # abcde
print(a[:])         # abcdefg
print(a[1:6:2])     # bdf
print(a[6:1:-1])    # gfedc

print(a*2)          # abcdefgabcdefg

print(a+a+a)        # abcdefgabcdefgabcdefg

print(len(a))       # 7

还有python支持负数索引 -1为最后一个元素

程序中一般涉及到范围的比如切片 比如range(1,11)

这种都是顾首不顾尾的

序列互转

序列是可以互相转的

不过list和tuple互转就是()和[]的变化

转成字符串的话 是将内容放到引号中

In [87]: a = 'abc'

In [88]: list(a)
Out[88]: ['a', 'b', 'c']

In [89]: tuple(a)
Out[89]: ('a', 'b', 'c')

In [90]: b = [1,2,3]

In [91]: str(b)
Out[91]: '[1, 2, 3]'

In [92]: eval(str(b))
Out[92]: [1, 2, 3]

不过使用eval() 可以将字符串中的内容执行

In [92]: eval(str(b))
Out[92]: [1, 2, 3]

# 或者
a = '{"a":1}'
print(type(eval(a)))        # <class 'dict'>

不过如果要变成’123’这样的就需要使用

#遍历数组,将数组中的内容转换成str(如果对象中有元素不是字符串的话)
In [94]: b
Out[94]: [1, 2, 3]
In [102]: c = ''

In [103]: for i in b:
...:     c+=str(i)
...:

In [104]: c
Out[104]: '123'

# 如果对象中的元素都是字符串 就可以使用 "".join(对象)
In [105]: b = ['1','2','3']

In [106]: c = ''.join(b)

In [107]: c
Out[107]: '123'

# 使用高阶函数reduce
b = [1, 2, 3]
bn = reduce(lambda x, y: str(x) + str(y), b)
print(type(bn))     # <class 'str'>
print(bn)           # 123

序列解包

简单来说 *是解序列

**是解字典

两个值用,来连接可以看成是一个整体,这个整体是一个元组

序列_字符串

字符串是字符的序列

在python中单引号和双引号的工作机制相同,都是包括一串单行的字符

在python中三引号可以包括一段多行字符串(如果没有赋值给变量的,那么三引号字符串表示多行注释)

内置的字符串对象的值是不可变的

a = '123'
a[1]= '4'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-aaeffe9cfb23> in <module>()
----> 1 a[1]='4'

TypeError: 'str' object does not support item assignment

字符串拼接不是修改,是新创建一个字符串对象,然后变量指向了新的对象

打印两个汉字 比如’理解’

py3中 len(s) 返回值是2 因为py3计算的是字符

py2中 len(s) 返回值是6[utf-8] 或者4[gbk] 因为py2计算的是字节

这点上从for循环遍历的结果上就能看出来

python的字符串格式化

- %s

- “{}”.format()

# %的方式
# '%s'%value
# '%s%s'%(value1,value2,value3)
# %s在传入的过程中会进行str(value)的操作 所以通过%s传什么都可以

a = "a%sb%sc" % (1, 1)
print(a)        # a1b1c

b = "a{0}b{1}c".format(1,1)
# 传*序列 或者元组的话 用索引获取
print(b)        # a1b1c

d = "a={a},b={b}".for
ed49
mat(a=1, b=2)
#传**字典或者键值对的话 用键获取

print(d)

当然,也可以使用字符串拼接(不过还是建议用format格式化)

c = "a" + "1" + "b" + "1" + "c"
print(c)    # a1b1c

转义符 \

原始字符串 r”字符串内容”

还有可能会用到的

字符串方法

"+".join(['1','2','3','4']) 将序列,集合中的所有元素添加到新的空字符串中,每个元素之间的分隔符为"+"
# In [68]: "+".join("abc")
# Out[68]: 'a+b+c'
# 如果join传的是字典的话,那么只添加key
# join方法要求传入的对象中元素必须都是字符串

"1+2+3+4".split("+") 将字符串以+作为分割符分割成list
.splitlines() 以换行符作为分割符 分隔成list
.partition("aaa") 原字符串以aaa为中心 分隔成三份 返回一个元组
# "dddaaaddd".partition("aaa")
# ('ddd', 'aaa', 'ddd')
.rsplit
.rpartition
# split和rsplit如果不指定分隔符的话,默认以空白符号(空格 换行等)作为分隔符
# split和rsplit可以指定分隔次数,比如可以分成10份的情况下,第2个参数写2 就是分成3份  写1就是分成2份

.upper() 转换成大写
.lower() 转换成小写
.capitalize() 一句话的首字母大写
.swapcase() 大->小 小->大
.title() 一句话每个单词的首字母大写(变成标题)

.count("a") 一个字符串在另一个字符串中出现的次数

.center(20,"#") 一共20个字符 原字符串的位置在中间,两边为#
.ljust(20,"#") 一共20个字符 原字符串的位置在左侧 右边为#
.rjust(20,"#") 一共20个字符 原字符串的位置在右侧 左边为#
.expandtabs(20) 将字符串中的abc\t替换成abc+17个空格
# In [45]: 'a\tb\tc'.expandtabs(4)
# Out[45]: 'a   b   c'

.zfill(30) 指定字符串的长度为30 左侧补0

.endswith("-end") 如果以-end结尾返回True
.startswith("start-") 如果以start-开头返回True

.index("a") 字符第一次匹配的索引位置,可以继续传参数指定范围
# .index("a",4,10) 在字符串是索引4到索引9之间查找
.rindex() 从右边开始找
.find() 返回找到的第一个字符的索引
.rfind() 从右开始找
# find和rfind没有找到的话返回-1
# index没有找到会抛异常ValueError

.format() 格式化输出
{0}{1}{2} 对应(第一项,第二项,第三项)
{name1}{name2}{name3} 对应{name1=x,name2=y,name3=z}
.format(**dict) 这个用到的解包
.format_map(dict)   #dict是一个字典

.isdight() 是否只有整型数字
.isdecimal() 是否只有十进制整数
.isalnum() 是否只有字母或数字
.isalpha() 是否只有字母
.islower() 是否只有小写
.isupper() 是否只有大写
.istitle() 是否每个单词的首字母大写
.isspace() 是否都是空格
.isidentifier() 是否合法标识符
# 'def'.isidentifier() 的返回值也是True

.isnumeric() 这个方法也能判断数字,不过这个方法还可以判断汉字和罗马数字
# In [64]: '一'.isnumeric()
# Out[64]: True
#
# In [65]: '壹'.isnumeric()
# Out[65]: True
.isprintable() 是否不存在不可显示的字符
# In [66]: 'abc'.isprintable()
# Out[66]: True
#
# In [67]: 'abc\t'.isprintable()
# Out[67]: False

.strip() 默认去掉字符串两端的空白字符,也可以传参数去掉指定的内容
.lstrip() 去掉左边的
.rstrip() 去掉右边的
# 但是主要的作用还是去空格

.replace() 替换
# "xxabcxxertxxcde".replace("xx","pz",1)
# 'pzabcxxertxxcde' 只替换了一次
# "xxabcxxertxxcde".replace("xx","pz")
# 'pzabcpzertpzcde' 全部替换

table = ''.maketrans('abc','123')
s = 'abcdef'
print(s.translate(table))       #'123def'
# 字符串的maketrans方法的返回值会生成一个字符映射表
# 使用字符串s 调用translate方法 传入table作为参数
# 可以将s字符串中所有的a替换成1 b替换成2 c替换成3

相对来说最重要的

- join

- upper / lower

- find

- strip

- split

屏蔽敏感词案例

# 敏感词

a = ['aaa','bbb','ccc']
s = 'dsajd;1p2k1p,l21aaad1pl12,;nnbbbe21klm12l;meccce1mp;ldf1'

for w in a:
if w in s:
s = s.replace(w,'***')

print(s)

序列_列表

列表可以存一组数据,这句数据的数据类型可以不相同

数据类型可以的值,也可以是对象,函数名

不过通常来说都是存相同数据类型的值

创建一个空列表 a = []

创建一个列表 num = [1,2,3]

列表是可以嵌套(因为列表也是对象)

列表方法

增

.append(obj) 将一个元素插到末尾
.insert(index,obj) 插到指定位置
.extend(seq) 一次性插入多个值
比如extend([5,6,7]) 往原有列表中传入5,6,7
extend([8,[9],[10,11]) 往原有列表中传入8,[9], [10, 11]

list[len(arr):] = [value1,...]  也是在末尾追加
list1+list2 等价于list1.extend(list2)

删
.remove(obj) 删除指定元素,这里不能直接用索引 可以remove(list[index])
.pop() 默认删除最后一个元素 并返回该元素
.pop(index) 删除指定索引位置上的元素 并返回该元素
.clear() 清空列表
del list[索引/切片] 或者直接del list

改
list[索引]=value
list[切片]=list2/tuple2

查
list[index]
value in list[index]
value not in list[index]
.count(obj) 统计元素出现次数
.index(obj) 从列表中找出某个值第一个匹配项的索引位置

.reverse() 反转列表
.sort() 排序 按照ascii码排序
.sort(reverse=True)
# def sort(self, key=None, reverse=False)
.copy() 列表浅拷贝

列表推导式

格式

>>> [i for i in range(1,11)]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for循环的前面是一个和i有关的表达式,可以配合一个三元运算符

>>> [i**2 if i>3 else i**3 for i in range(1,11)]
[1, 8, 27, 16, 25, 36, 49, 64, 81, 100]

for循环的后面可以跟一个条件判断,比如不想出现7

>>> [i for i in range(1,11) if i!=7 ]
[1, 2, 3, 4, 5, 6, 8, 9, 10]

序列_元组

元组可以看成是一个不可修改的list

元组可以调用两个不带下划线的方法 index/count

但是元组中如果有list或者dict的话,是可以进行修改的(但是一级元素的内存地址不变)

定义一个元组 至少需要一个元素和一个,

否则

>>> type(('abc'))
<class 'str'>
>>> type(1)
<class 'int'>

>>> type(('abc',))
<class 'tuple'>
>>> type((1,))
<class 'tuple'>

在python中如果出现了

变量1,变量2

这种情况,就可以将他们看成是一个元组

(变量1,变量2)

例如 如果函数返回了多个值,那么返回值的类型就是元组

元组还可以进行一些操作

a,b = b,a

c,d = (1,2)
print(c)    # 1
print(d)    # 2

映射类型_字典

字典中存放一些键值对

{key:value}

字典是无序的

key必须是不可修改类型(可hash类型 比如字符串 数字 元组)

字典中的key是不能重复的

如果key是布尔值的话,可能会和数字0/1冲突,key对应的value会进行覆盖

dic = {

True: 2,
3: 3,
1: 1
}

print(dic)

# 打印输出
# {True: 1, 3: 3}

字典方法

取值
dict[key]
dict.get(key)
这两个是返回key对应的value 找不存在的key不会报错
dict.get(key,0) get使用get方法获取值可以设置默认的value值
dict.setdefault(key,value)
如果key存在不进行操作 返回key对应的value
如果key不存在,添加一个key:value 返回key对应的value

查
dict.keys()
dict.values()
dict.items()
分别返回(py3中 2中是列表)
dict_keys([key1,key2,...])
dict_values([value1,value2,...])
dict_items([(key1,value1),(key2,value2),...])

增
dict[key]=value
dict.get(key)=value
dict.update(dict2)
将dict2加入到dict,如果有相同的key 后面更新的覆盖原有的
update(k1=v1,k2=v2,...)  还支持这样的写法

删
dict.clear() 清空字典
del dict(key)
del dict
dict.pop(key) 删除指定的键值对,并返回该键值对的value
pop方法可以设置默认值 当删除失败的情况下返回默认值
dict.popitem() 随机删除一个键值对,并以元组的方式返回键值对(key,value)

其他操作
dict.fromkeys([key1,key2,key3,...],value)
返回一个字典{key1:value,key2:value,key3:value}

嵌套
{
{},
{},
{}
}

字典遍历
for i in dict:
print(i,dict[i])

for k,v in dict.items():
print(k,v)

for key in dict.keys():
print(key)     #只遍历key

for value in dict.values():
print(value)    # 只遍历value

字典中最常用的

- keys/values/items()

- get()

- update()

字典应用

1 检查一个字符串中有多少的数字 多少字母

a = 'dj10i3kltm1qf0j2`091rjmqf120jfoklm34yg3mlgemf;'
dic = {}
for i in a:
if i.isdigit():
dic['num'] = dic.get('num', 0) + 1
if i.isalpha():
dic['alpha'] = dic.get('alpha', 0) + 1

print(dic)

# 输出结果
# {'alpha': 29, 'num': 15}

2 仿switch

'''
i = 1
switch(i){
case 1:
console.log(1);
break;
case 2:
console.log(2);
break
case 3:
console.log(3):
break;
}

'''

switcher = {
'1': lambda: print(1),
'2': lambda: print(2),
'3': lambda: print(3),
}
i = 1
switcher[i]()

集合

python的集合是一种无序,且不重复的数据容器



转成集合就相当于for循环遍历对象,然后判断遍历出来的元素是否重复

然后在将元素放到集合中

集合的一些方法

add 添加元素 只能传一个
clear 清空
copy 浅拷贝
pop()  随机删除并返回一个元素
remove(obj) 指定要删除的元素 不存在的话会报错
discard(obj) 删除元素不存在的话不会报错
update() 更新集合 可以传多个值

这里说明一下 如果是简单的去重,不考虑顺序问题的话

可以使用集合

& 交集

| 并集

左

-

右 差集 左边有右边没有的

左^右 对称差集(并集-交集)







set是可变集合

frozenset是不可变的集合