第二章：数字类型

一 复习

数据类型

int

python2存放长整型 Long

py3 环境 所有整形均由Int存贮

complex

cp=3+6j

print(cp,type(cp))

bool :true false 在内存中就是存贮零一

isinstance (obj,type)

判断某对象是否是某类型，返回值是一个Bool类型。

print(isinstance(True,int))=====True

print(isinstance(False,int))=====True

bool 类型在存贮中是以01存贮的 所以是int类型 这里需要特别注意下

字符串

‘ ‘

’‘ ’‘

’‘’ ‘’‘’

s='hello world!!!'

1，索引取字符s[]

2，切片

res = s[6:10:1] 顾头不顾尾

3，拆分

res=s.split(' ')

4 替换replace

5 count 查找字符串中子字符串中出现的次数

6 字符串的长度 len

7 判断是否能转换成int

8 大小写切换

print('asd'.uper())

print('ASD'.lower())

list :可变

自身指向的内存空间 地址 不发生改变时，可以改变地址指向的空间空间中的内容

增删改查

插入

list1=[1,2,3,4,5]

list1=list1.insert(3,222)

print(list1)

在索引号为3，也就是第4个位置之前，注意 是之前，插入222，

打印的结果是[1,2,3,222,4,5]

删

del list1[2]

删除列表的某一个值 删除列表索引号为2的值

翻转

s.reversr()

排序

s.sort()

如果要反排序

s.sort(reversr=True)

多值添加

list1=[0,1,2]

list1.extend('abc')

print(list1)

可以被for 循环的类型就是可迭代类型

for v in 'abc':

​ print(v)

for o in [10,20,30]:

​ print(o)

元组：不可变的list

元组于列表的转换

元组：不可变

列表：可变

字典：没有索引 无序存贮 按key 存贮

dic={}

增删改查

增 改

dic['name']='Bob'

删

1, del dic['name']

dic={'name':'bob','age':'24','gender':'male'}

2,res= dic.pop('age')

3,dic.popitem()

例如：

dic = {'name':'szp','age':24,'gender':'male'}

dic.popitem()

print(dic)

程序运行结果：

{'name': 'szp', 'age': 24}

从最后删除，返回（k,v）

k,v = dic.popitem()

print(k.v)

按照['key']查

print(dic['name']) Key不存在时，抛异常

dic['name'] = 'bob

key存在时，直接将原来的值改成新的值，但是如果key不存在时，就会抛出异常

用下面的这个get的方法就不会抛出异常

print(dic.get('name','key不存在'))

当key不存在时，get 方法会将第二个位置的值，这里也就是'key不存在'返回，也就是打印出来的结果。

设置默认值：如果原来的字典中，没有该默认值，就直接添加并设置默认值，如果原来字典中，有该参数，就不会操作。

dic={'name':'szp','salary':'6666','height':180}
dic.setdefault('salary','8888')######这个默认设置，原值存在，所以不会操作不会修改
print(dic)
dic['heighe'] = 185
print(dic)###################这个直接修改了值
​

设置默认值:没有该key则添加并设置默认值，如果有，不做操作

通过Key初始化字典

dic ={'name':'szp','age':24,'gender':'male'}
dic.fromkeys(('name','age','gender'),None)####通过默认值给None  一般省略

字典循环

多值更新,有值更新，无值添加，而且可以添加多个

dic={'name':'engo'}
​
dic.update({'name';'egon','age':'24','gender':'male','salary':'8888})
​
print(dic)
###字典类似与列表类型，不能直接通过index取值，但是可以被for 循环迭代取值
print(dic.keys())
print(dic.values())
print(dic.items())
            

dic={'name':'engo'}
for k in dic.keys():
    print(k,':',dic[k])
print('--------------------------------------------------------')
for v in dic.values():
    print(v)
print('---------------------------------------------------------')
for  k,v in dic.items():
    print(k,v)
############列表的解压赋值
a,b,c=[1,2,3]
print(a,b,c)
####如果列表的值多了，多余的可用下划线或者其他字符来接收
a,b,_,_ = [1,2,3,4]
print(a,b,_)#### 1 2 4
​
​

字典和列表的循环嵌套

也就是JSON数据

dic = {'students':[
                {'name':'xiaoming',
                  'age':24,
                  'gender':'male'
                },
                {'name':'xiaoli',
                  'age':25,
                  'gender':'female'
                }
]
,
       'teacher':[{'name':'lilaoshig',
                  'age':43,
                  'gender':'male'
                },
                 {'name':'wanglaoshi',
                  'age':54,
                  'gender':'female'
                }]  
}
print(dic['students'][1]['age'])
#####字典与列表循环嵌套的时候只需要一层一层的取值 一层一直的查找就可以
print('===========================================================')
for k,v in dic.items():
    #####只遍历学生
    if k == 'students':
        for stu in v :
            for s_k,s_v in stu.items():
                print(s_k,':',s_v)
            print('===================================')
    if k ==  'teachers'：
        pass
    

集合：set 无序 无Key 无索引

特点：存放数据具有唯一性：去重

应用场景：处理大量有重复信息的数据，对其去重，如果需要取值，将其转换成列表list

网络爬虫上广泛应用

s = set()
s.add('a')
print(s)
s.add('b')
s.add('a')
s.add('b')
s.add('c')
print(s)
###set集合也支持遍历
for v in s:
    print(v)

多个set 完成关系运算

py= {'a','b','c','egon'}

ln={'x','y','z','egon'}

只报python

res=py - ln

反过来 只报linux

res =ln-py

两个都报的

res= py & ln

只报一门的

res =py ^ ln 拖字符

报名的所有学生

res=py | ln 联合