复习：
流程控制for循环
做重复的事情，在循环取值上比while更简单
for x in 可迭代对象：（只要包含多个值，就可以被for执行）次数取决于in之后包含的值的个数
print(x)
对比while：
1、相同：都是循环，for能做的，while都能做
2、不同：
for村换次数取决in后值的个数
while循环次数取决条件何时为假
for+range（0，10,2）起始位置，结束位置，步长（一次加多少）
嵌套,for+else,for+break,for+continue
外层循环一次，内层所有的循环都要循环一次
for i in range(len(l)):
print (i,l[i])
基本数据类型(作用，定义，类型转换，内置方法（python提供好的底层操作数据的功能）)
int
float
str
有序类型=》无序类型
强调：str可以按照索引取值，但是只能取，不能改
------------今日内容-------------
基本数据类型极其内置方法
1、列表（list）
作用：存多个值，按照索引的顺序来对应值
定义：中括号内，用逗号分隔开，任意类型的值
l = [1,1.2,'a'] # l = list([1,1.2,'a'])调用了这个功能
类型转换：单反能够被for循环遍历（循环）的类型都可以给参数传给list()转成列表，str可以
res = list("hello")
res = list({'k1':111,'k2':222,'k3':333})
内置方法：
按照索引取值（正向+反向）既可以取，也可以改
l = [111,'egon','hello']
正向取：
print(l[0])
反向取：
print(l[-1])
改：（无论是取还是赋值操作，索引存在则修改对应的值，索引不存在则报错）
l[0] = 222
往列表里添加值：
追加：
l.append(333)
插入值：
l = [111,'egon','hello']
l.insert(0,'alex') # 第一个参数为索引
切片：
l = [111,'egon','hello','a','b','c','d']
print (l[0:5:2])
print (l[0:len(l)]) # print (l[:])
new_l = l[:] # 切片相当于copy行为，而且相当于浅copy(默认copy都是浅copy)
长度：len()统计长度
print(len([1,2,3]))
成员运算in和not in：
print('aaa' in ['aaa',1,2])
末尾插入值：
new_l = [1,2,3]
l = [111,'egon','hello']
代码实现：
for item in new_l:
l.append(item)
print(l)
extend实现上述代码：
l.extend(l)
删除：
del：(解除绑定关系，通用删除方法（列表，变量，字典），且没有返回值，只是单纯的删除)
x = del l[1] # 不支持复制语法（抛出异常）
l.pop：（根据括号内索引删除，不指定索引默认删最后一个，会返回值，返回的是被删除掉的值）
l = [111,'egon','hello']
res = l.pop() # 默认删除最后一个
l.remove()：根据元素删除，返回None
l = [111,'egon','hello']
l.remove('egon')
res = l.remove('egon')
print(res) # 返回的是None
如果只是想单纯删除一个元素：del，remove
如果想删掉并且拿到被删元素：pop
循环：
for x in [1,'aaa','bbb']:
print (x)
需要掌握的：
l.count() # 统计出现了几次
l.index() # 查找某一元素的索引，找不到会报错
l.clear() # 清空整个列表的元素
l.reverse() # 将列表反转，不是排序，就是倒过来
l.sort() # 默认从小到大排，但是列表内的元素必须是同种类型才能排序（升序）
l.sort(reverse=True)从大到小排列，设置为降序；reverse默认为False
字符串也可以比较大小，按照对应位置的字符依次比较，按照ASCI码表顺序区别，越是靠后越大
列表之间也可以比较大小，原理同字符串一样，两个列表的对应类型，必须是同种类型，不同种类就会报错
补充：
队列：first in(FI先进)&first out(FO先出)
l = []
#入队操作
l.append('first')
l.append('second')
l.append('third')
#出队操作
print(l.pop(0)) # 先得到first
print(l.pop(0)) # 得到second
print(l.pop(0)) # 得到third
堆栈：LIFO，后进先出
l = []
入栈操作
l.append('first')
l.append('second')
l.append('third')
出栈操作
print(l.pop()) # 得到third
print(l.pop()) # 得到second
print(l.pop()) # 得到first
1、元祖（tuple）（不可变的列表）如果元祖里的元素是可变类型，可以改变可变类型的值
作用：是“一个不可变的列表”，按照索引（位置）存放多个值，只用于取，不用于改
定义：()内用逗号隔开多个任意类型的元素
t = (1,1.3,'aa') # t = tuple(1,1.3,'aa') 0号索引对应值1的内存地址，1->值1.3的内存地址，2->'aa'的内存地址
x = (10) # 单独一个括号代表包含的意思
x = (10,) # 如果元祖中只有一个元素，必须加逗号
类型转换：
tuple() # 可以转换字符串，列表，字典
内置方法：
t=('aa','bbb','cc')
索引取值（正反）
正：print(t[0])
反：print(t[-1])
切片(顾头不顾尾，步长)
t = ('aa','bbb','cc','dd','eee')
print(t[0:3]) # 正切
print(t[::-1]) # 反切
同级长度
t=('aa','bbb','cc','dd','eee')
print(len(t))
成员运算in和not in
print('aa' in t)
循环
for x in t:
print(x)
index搜索序列
t=(2,3,111,111,111,111)
print(t.index(111))
print(t.index(1111111111))
count计数
print(t.count(111))
如果需要只读不改的操作的时候，可以使用元祖
2、字典(dict)：
作用：用来记录多个值，用key对应值
定义：{}内用逗号分隔开多个key:value，其中value可以是任意类型，但是key必须是不可变类型
d = {'k1':111,(1,2):222} # d = dict(...)
print(d[(1,2)])
d = {} # 默认定义出来的是空字典
d = dict(x=1,y=2,z=3) # 可以用{}，可以按照这样的方式
类型转换：
info = [
['name','egon'],
('age',18),
['gender','male']
]
d = {}
for item in info : # item = ['name','egon']
d [item[0]] = item[1]
print(d)
res = dict(info) # 一行代码搞定上述for循环的工作
print(res)
keys=['name','age','gender']
value = None
d = {}
for k in keys:
d[k] = None
print(d)
d = {}.fromkeys(keys,None) # 相当于上述代码（快速初始化一个字典）
print(d)
造字典的方式：
1、d = {} # 默认定义出来的是空字典
2、d = dict(x=1,y=2,z=3) # 空字典
3、res = dict(info) # 针对列表，列表内的对应值转变成字典
4、d = {}.fromkeys(keys,None) # 快速初始化一个字典，所有的key都对应一个value（None）
内置方法：
按key存取值：可存可取
d={'k1':111}
针对赋值操作：key存在，则修改
d['k1']=222
针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d)
长度len
d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d)
print(len(d))
成员运算in和not in:根据key
d={'k1':111,'k2':2222}
print('k1' in d)
print(111 in d)
删除
d={'k1':111,'k2':2222}
通用删除
del d['k1']
print(d)
pop删除：根据key删除元素，返回删除key对应的那个value值
res=d.pop('k2')
print(d)
print(res)
popitem删除：随机删除，返回元组(删除的key,删除的value)
res=d.popitem()
print(d)
print(res)
键keys()，值values()，键值对items() =>在python3中得到的是老母鸡
d={'k1':111,'k2':2222}
在python2中
>>> d={'k1':111,'k2':2222}
>>>
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>> dict(d.items())
{'k2': 2222, 'k1': 111}
for循环
d={'k1':111,'k2':2222}
for k in d.keys():
print(k)
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
需要掌握的内置方法
d={'k1':111}
1、d.clear() # 清空字典
2、d.update() # 添加新的东西到字典里，没有的就创造一个
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d)
3、d.get() ：根据key取值，容错性好
print(d['k2']) # key不存在则报错
print(d.get('k1')) # 111
print(d.get('k2')) # key不存在不报错，返回None
4、d.setdefault() # 原来字典里没有的元素，就将其添加进去
info={}
if 'name' in info:
... # 等同于pass
else:
info['name']='egon'
print(info)
4.1 如果key有则不添加,返回字典中key对应的值
info={'name':'egon'}
res=info.setdefault('name','egon')
print(info)
print(res)
4.2 如果key没有则添加，返回字典中key对应的值
info={}
res=info.setdefault('name','egon')
print(res)
3、集合
pycharm查看说明:按住ctrl键，鼠标移到内置方法处，会有说明
按住ctrl键，鼠标移动点击，会有说明文档
浙公网安备 33010602011771号