布尔值
在python中
None/False/空字符串”“/0/空列表[ ]/空字典{ }/空元组( )都相当于False，其它的都相当于True。
布尔值可以用and、or和not运算。
布尔值经常用在条件判断中，比如：
if age >= 18:
print('adult')
else:
print('teenager')
and运算是与运算，只有所有都为True，and运算结果才是True：
>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True
or运算是或运算，只要其中有一个为True，or运算结果就是True：
>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True
not运算是非运算，它是一个单目运算符，把True变成False，False变成True：
>>> not True
False
>>> not False
True
>>> not 1 > 2
True
列表（list）和元组
python中的列表类似于其它语言中的数组，是一种从0开始排序，并且是顺序排列的元素集合，可以随时添加和删除其中的元素（元素从前往后的序号是1，2，3，4，从后往前的序号是-1，-2，-3，-4）
列表主要用法
主要用法可分为增、删、改、查四大部分：
| 类别 | 语句格式 | 用法说明 |
| 通用 | help(list) | 列表的帮助：列出所有列表的用法 |
| type(name) | type判断数据类型是列表还是字典或者元组 | |
| list=[‘name’，’mango’] | 创建列表，用逗号分隔的不同的元素并使用方括号括起来 | |
| 3in[1,2,3] | 结果为True，验证元素是否存在于列表中 | |
| foriinlist | 遍历列表，将表中的元素依次赋值给i | |
| 增 | list.append(‘rice’) | 增：列表末尾添加一个项目 |
| list.insert(2：”cjk”) | 增：在列表的第三个位置插入一个元素：列表排>序从0开始算 | |
| 删 | dellist[0] | 删：根据索引删除列表中的项目：删除第一个元素 |
| list.remove(‘apple’) | 删：根据内容删除元素 | |
| list.pop() | 删：删除最后一个元素并输出 | |
| 改 | list[0]=”apple” | 改：通过索引修改：把list>列表中第一项改成“apple” |
| 查 | len(list) | 查：查看列表的元素个数 |
| max(list) | 查：列表中的最大值 | |
| min(list) | 查：列表中的最小值 | |
| list.count(‘apple’) | 查：输出列表中某个元素的个数 | |
| ifappleinlist | 查：搜索apple是否在列表中 | |
| list.index(“apple”) | 查：输出apple元素在列表中的位置（索引号） | |
| list[0] | 分片查（切>片）：输出索引为0的元素：即第一个元素 | |
| list[0:2] | 分片查（切片）：输出前三个元素 | |
| list[:] | 分片查（切片）：输出所有 | |
| list[1:] | 分片查（切片）：输出第二个和后面所有的 | |
| list[0:-1] | 分片查（切片）：除了最后一个都输出 | |
| list.sort() | 查：将项目按首字母排序：数字>大写>小写 | |
| list.reverse() | 查：项目顺序倒转 |
拼接字典，数据类型判断
将字典中对应key的值拼成列表
>>> list=['a','b','c']
>>> data={'a':'1','b':'2','c':'3'}
>>> [data[x] for x in list]
['1', '2', '3']
>>>
数据类型判断：tpye和isinstance
type
格式： type(数据或者变量)
>>> type('asc')
<type 'str'>
>>>
>>> list1=['a','b','c']
>>> type(list1)
<type 'list'>
>>> data={'a':'1','b':'2','c':'3'}
>>> type(data)
<type 'dict'>
>>>
isinstance
格式： isinstance(变量或数据，数据类型) –>返回布尔值
>>> a=['1','2']
>>> isinstance(a,list)
True
>>> data={'a':'1','b':'2','c':'3'}
>>> isinstance(data,dict)
True
小练习：列表去重
a = [1,1,2,3,4,5,6,7] ，要求把列表a的重复项消除
思路1：在原有的列表中找到重复的元素，然后删除这个元素
1) 判断列表中所有元素出现的频率，如果大于2，则获取他们的索引，列表.index(元素)
2) 拿到索引之后，将多余的元素按索引删除即可
>>> a = [1,1,2,3,4,3,5,6,7]
>>> for i in a:
... if a.count(i) >1:
... del a[a.index(i)]
...
>>> a
[1, 2, 4, 3, 5, 6, 7]
>>>
思路2：新建列表 ，将不重复的元素挪到新列表中
1) 新建一个列表，作为新的存储
2) 循环老的列表，并将遍历的元素添加到新列表中，同时进行判断，如果该元素已经在新的列表中就pass
3) 最终新列表中就只有不重复的元素了
>>> b=[]
>>> a = [1,1,2,3,4,3,5,6,7]
>>> for i in a:
... if i not in b:
... b.append(i)
...
>>> b
[1, 2, 3, 4, 5, 6, 7]
>>>
简单粗暴式：set集合
>>> a = [1,1,2,3,4,3,5,6,7]
>>> list(set(a))
[1, 2, 3, 4, 5, 6, 7]
>>>
join()和split()语句
.join()用法：“分隔符”.join(列表)—把列表转换成字符串
>>> seq1=['a','b','c']
>>> print '/'.join(seq1)
a/b/c
>>>
split()用法：字符串.split(‘分隔符’)—把字符串变成列表
语法：‘字符串’.split(‘分隔符’，分割次数)
分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。也可以自己指定分隔符样式。
1.按某一个字符分割，如‘.’
>>> str=('www.baidu.com')
>>> str.split('.')
['www', 'baidu', 'com']
>>>
2.按某一个字符分割，且分割n次。如按‘.’分割1次
>>> str=('www.baidu.com')
>>> str.split('.',1)
['www', 'baidu.com']
>>>
遍历列表
方式一：普通遍历
>>> list1=['a','b','c']
>>> for i in list1:
... print i
...
a
b
c
>>>
方式二：enumerate
>>> list1=['a','b','c']
>>> for i in enumerate (list1):
... print i
...
(0, 'a')
(1, 'b')
(2, 'c')
enumerate可以同时返回列表中元素的序号和元素值，多用于在for循环中计数，enumerate参数为可遍历的变量，如 字符串，列表等
元组
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
>>> classmates = ('Michael', 'Bob', 'Tracy')
现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。 因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
字典 — Dictionary(dict)
把目录（键，key）和详细信息（值，value）联系在一起就形成了字典。 键相当于字典的目录，可以通过一个目录来找到与之相对于值。换句话来说，目录就是内容的一个特殊标示，即每一个目录，都会在字典有中有与之相对应的详细信息。也就是说，字典中的每一个目录都是唯一的，与字典中的其他目录互不冲突。（字典中的数据是无序排列）
字典的值可以是任意数据类型,包括字符串,整数,对象,甚至其它的字典。在单个字典里, 字典的值并不需要全都是同一数据类型,可以根据需要混用和匹配。但是键就比较严格了，一般字符串,整数（我知道的只有这两种）。
字典主要用法：
主要用法依旧分为增、删、改、查四大部分：
| 类别 | 语句格式 | 用法说明 |
| 通用 | len(dict) | 得到字典中元素的个数 |
| dict.copy() | 得到字典副本 | |
| foriindict(): | ||
| fork,vindict.iteritems(): | ||
| 增 | dict[‘fengjie’]=’123467524’ | 增：列表末尾添加一个项目 |
| 删 | dict.pop(k) | 删除key,并提示对应的value |
| deldict[k] | 删除key，不提示对应value | |
| dict.clear() | 删除字典中的所有元素 | |
| 改 | dict[k]=v | 改设定>字典中键k所对应的值成为v |
| dict[k][2]=30 | 改内部套用列表的列表 | |
| dict[‘other’][‘test’]=654321 | 改内部套用字典的列表 | |
| dict.update(dist2) | 改将两个字典合并 | |
| 查 | dict.keys() | 输出所有key |
| dict.keys()[-1] | 查看字典的所有的键，以列表存储，[-1]为最后一个键 | |
| dict.values() | 查询所有的值,以列表储存 | |
| dict.has_key(k) | 判断字典中是否含有键k | |
| dict.items() | 以列表返回可遍历的(键,值)元组数组 | |
| kindict | 字典中存在键k则为返回True，没有 则返回False | |
| dict.get(“k”，dafault) | 从字典中取出键为k的值，如果k不存在，可以返回None，或者自己指定的value | |
| dict[“key”] | 同上获取指定key的值,如果key不存在会报错，故更推荐上面的用法 | |
| dict.setdefault(k,default=None) | 从字典中取出键为k的值，如果k不存在，往 字典中插入None，或者自己指定的value，并返回该值 |
遍历字典
首先，我们创建一个字典dict = {‘a’:1,’b’:2,’c’:3,’d’:4}，分别用不同的方式遍历，看看会有什么结果
1) 普通遍历for i in dict ：
>>> dict = {'a':1,'b':2,'c':3,'d':4}
>>>
>>> for i in dict:
... print i,dict[i]
...
a 1
c 3
b 2
d 4
>>>
2) 用dict.items()遍历：
>>> for k,v in dict.items():
... print k,v
...
a 1
c 3
b 2
d 4
如果不好理解，可以将上段代码拆成2段来理解：
>>> d=dict.items()
>>> d
[('a', 1), ('c', 3), ('b', 2), ('d', 4)]
>>> for k,v in d:
... print k,v
...
a 1
c 3
b 2
d 4>>> d=dict.items()
>>> d
[('a', 1), ('c', 3), ('b', 2), ('d', 4)]
>>> for k,v in d:
... print k,v
...
a 1
c 3
b 2
d 4
3) 用dict.iteritems()遍历：
>>> for k,v in dict.iteritems():
... print k,v
...
a 1
c 3
b 2
d 4
如果遍历存有较多数据的字典时，建议使用第一和第三种方式，第二种方式速度较慢，因为dict.items()会将字典转化成列表，每循环一次都需要查找整个列表，运行速度要比1,3方式慢。
字典的格式化输出
方法一： 笨方法，如果格式化输出时，有元素不属于字典时用这种
>>> dict = {'a':1,'b':2,'c':3,'d':4}
>>> print '%s,%s,%s,%s'%(dict['a'],dict['b'],dict['c'],dict['d'])
1,2,3,4
方法二： 推荐方式，如果所有元素都属于字典，用这种方式
>>> dict = {'a':1,'b':2,'c':3,'d':4}
>>> print '%(a)s,%(b)s,%(c)s,%(d)s'%(dict)
1,2,3,4
>>>
练习
users= [{‘age’:18,’job’:’coo’,’name’:’jeffry’,’passwd’:’123456’},{‘age’:19,’job’:’cto’,’name’:’cheng’,’passwd’:’12345’}]
练习要求及思路
已知用户信息的列表users，要求：
1) 判断用户是否在列表中 if else — 需要循环列表，取到对应的name
2) 如果用户不存在，退出；
3) 如果用户存在，则判断密码是否正确 — 取到对应的密码；
4) 如果用户密码都正确 — 打印该用户的信息
代码：
vim lianxi.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import sys
us = raw_input('Please input uername:')
users= [{'age':18,'job':'coo','name':'jeffry','passwd':'123456'},{'age':19,'job':'cto','name':'cheng','passwd':'12345'}]
name = []
for i in users:
name.append(i['name'])
for key in users:
if us not in name:
print '用户不存在'
sys.exit()
if us == key['name']:
ps = raw_input("Please input user passwd:")
if ps == key['passwd']:
print '欢迎:%s'%(key['name'])
print "您的用户信息:%s"%(key)
else:
print "密码错误!"
else:
continue
执行结果：
[root@instance-5ql4qny2 ~]# python lianxi.py
Please input uername:jeffry
Please input user passwd:123456
欢迎:jeffry
您的用户信息:{'passwd': '123456', 'age': 18, 'job': 'coo', 'name': 'jeffry'}
[root@instance-5ql4qny2 ~]#
列表和字典有什么区别，分别适用于什么场景？
简单说，如果你需要一组有序的数列（0,1,2,3），用列表，如果你需要一组有对应关系的数据，用字典。
在查找大量数据时，用字典比列表快得多。
文件操作
主要用法
| 类别 | 语句格式 | 用法说明 |
| 文件读写基本操作 | f=open(“文件路径及文件名”) | 打开文件file=open， 默认只读 |
| f.read() | 读取,一次全部读完，结果为一个整体的字符串 | |
| f.readline() | 按行读取文件，每执行一次读取一行 | |
| f.readlines() | 按行读取文件，并将每行的字符串组成列表 | |
| f.write(“str”) | 单条写入，f是文件句柄 | |
| f.writelines() | 多条写入 | |
| f.close() | 关闭文件，关闭后无法打开了 | |
| withopen(“文件路径及文件名”)asf: | 相当于f=open，但不 用关闭文件f.close() | |
| 用不同权限打开文件 | open(‘path’) | 默认只读打开，’path’表示”文件路径及文件名” |
| open(‘path’,’w’) | 写入，先删除源文件重新写入，没有文件自己创建 | |
| open(open(‘path’,’w+’)) | 读写。同上 | |
| open(‘path’,’a’) | 写入，在文件末尾追加新内容，文件不存在创建之 | |
| open(‘path’,’a+’) | 读写，同上，最常用的 | |
| open(‘path’,’b’) | 打开 二进制文件，要上述模式结合使用。读取图片 | |
| open(‘path’,’U’) | 支持所有的换行符号值\r\n\r\n |
文件读写方法展示
1) 单行、多行写入操作
>>> f = open('user.txt','a')
>>> f.write("wd:1234")
>>> names=["cheng:123\n","jeffry:123\n"]
>>> f.writelines(names)
>>> f.close()
[root@instance-5ql4qny2 ~]# cat user.txt
wd:1234cheng:123
jeffry:123
2) readlines()一次读取所有，结果以列表形式保存
>>> f = open('user.txt')
>>> f.readlines()
['wd:1234cheng:123\n', 'jeffry:123\n']
好，本次就写这么多，其实多把几个文件操作的函数练习练习，基本就差不多了，一般的日常脚本都可以写了
