目录：
一、变量
二、用户输入
三、模块
四、数据类型
五、运算
六、条件表达式
七、扩展
一、变量
1) 变量只能以字母或下划线开头，并以字母、数字和下划线组成
2) 不能以关键字命名变量名
例：'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield'
变量命名规划：
1) it_ls
:用下划线分割两个或以上的单词
2) AgentConfig
:每个单词首字母大写
3) chenForege
:首个单词小写往后的每个单词首字母大写
4) COMMON
:全大写可以定义一些全局的变量
5) _buff
:下划线可以定义一些特殊的变量或实例
6) fk_card
:简写和单词混用以下划线隔开
二、用户输入
input raw_input
1) 在3.0中它们是没有区别的
2) 在2.7中
input: 会根据输入变换不同类型(数字就为int 字符就为str )
若要将 int 类型的数字转换为 str 类型呢？
:在输入的时候将数字用双引号或单引号括起来('123')
raw_input: 把所有的输入都转换为 str 字符类型
若要将 str 类型的数字转换为 int 类型呢？
:int(raw_input()) 将输入的 数字 转换为 int 若输入的是字符就会报错
密码怎么实现密文输入？
# 利用 getpass 模块中的 getpass 方法。
import getpass
#引用模块
pass = getpass.getpass("Pleases password: ")
三、模块
模块是什么？
: 可以通俗的理解为，将一些常用的功能单独放到一个文件里面，当我们在其他文件中需要用到的时候，我们就可以通过调用的方式使用这个功能，这个功能文件就可以称为一个“模块”。
模块怎么调用？
调用 impor + 模块名
: import os
使用 模块名 + 具体的功能名字
: os.system()
调用自定义模块
: 将自定义的模块目录写入 path 环境变量中，调用方法和上面一样，但不能写后缀名
四、数据类型
#演示是使用的软件为 ipython 扩展中有该软件的安装方法
1) 整型
: int = 23
2) 布尔值
: bool = False
3) 字符串
: str = 'string' 或 "string"
4) 浮点型
: float = 2.3
5) 元组(不可变)
:tuple = (1, 2, 3, 4, 5 )
#切片
tuple1[-1]
tuple1[1:5]
tuple1[1:5:2]
In [4]: tuple[-1]
Out[4]: 5
In [5]: tuple[1:5]
Out[5]: (2, 3, 4, 5)
In [6]: tuple[0:5]
Out[6]: (1, 2, 3, 4, 5)
In [7]: tuple[0:5:2]
Out[7]: (1, 3, 5)
In [8]: del tuple
#Python元组的内置函数:
1. cmp(tuple1, tuple2)：比较两个元组元素（等于返回0，大于返回1，小于返回-1）。
2. len(tuple)：计算元组元素个数。
3. max(tuple)：返回元组中元素最大值。
4. min(tuple)：返回元组中元素最小值。
5. tuple(seq)：将列表转换为元组。
注：
1、当定义元组中只有一个数字时，就必须在数字后加逗号分割数字与括号的歧义
In [24]: t = (1) In [25]: t Out[25]: 1 In [26]: ttuple = (1,) In [27]: tuple Out[27]: (1,) 2、tuple
不可变是指tuple的元素不能变化。当一个tuple中有一个列表时，我们就可以改变列表中的值，但我们不能改变列表，因为列表是tuple的元素，列表的元素是可变的所以我们改变的是list的元素。（tuple指向的是这个列表，但列表的内容指向的是其他值，我们改变的只是列表的指向，并没有改变 tuple 的指向。）
In [54]: d = [1,2,3] In [55]: a = 1 In [56]: b = 2 In [57]: c = 3 In [58]: tuple = (a,b,c,d) In [59]: tuple Out[59]: (1, 2, 3, [1, 2, 3]) In [60]: tuple[3][0] = 4 In [61]: tuple Out[61]: (1, 2, 3, [4, 2, 3])
6) 列表
: list = [1,2,3,4]
#添加
list.append()
In [62]: list = [1,2,3,4]
In [63]: list
Out[63]: [1, 2, 3, 4]
In [64]: list.append(5)
In [65]: list
Out[65]: [1, 2, 3, 4, 5]
#插入
list.insert()
In [65]: list
Out[65]: [1, 2, 3, 4, 5]
In [66]: list.insert(0,8)
In [67]: list
Out[67]: [8, 1, 2, 3, 4, 5]
#删除
del list[]
list.remove()
In [67]: list
Out[67]: [8, 1, 2, 3, 4, 5]
In [68]: del list[0]
In [69]: list
Out[69]: [1, 2, 3, 4, 5]
In [70]: list.remove(2)
In [71]: list
Out[71]: [1, 3, 4, 5]
#修改
list[1] = x
In [75]: list
Out[75]: [1, 3, 4, 5]
In [76]: list[0] = 6
In [77]: list
Out[77]: [6, 3, 4, 5]
#查找
var in list
In [80]: list
Out[80]: [6, 3, 4, 5]
In [81]: 5 in list
Out[81]: True
In [82]: 7 in list
Out[82]: False
#可迭代，列表，字符，元组，数字
list.extend([])
In [86]: tuple
Out[86]: (1, 2, 3)
In [87]: list
Out[87]: [6, 3, 4, 5]
In [88]: list.extend([tuple])
In [89]: list
Out[89]: [6, 3, 4, 5, (1, 2, 3)]
#删除最后一个元素，并返回该值
list.pop()
In [90]: list
Out[90]: [6, 3, 4, 5, (1, 2, 3)]
In [91]: list.pop()
Out[91]: (1, 2, 3)
In [92]: list
Out[92]: [6, 3, 4, 5]
#排序
list.sort()
list.reverse()
In [92]: list
Out[92]: [6, 3, 4, 5]
In [93]: list.sort()
In [94]: list
Out[94]: [3, 4, 5, 6]
In [95]: list.reverse()
In [96]: list
Out[96]: [6, 5, 4, 3]
#搜索
list.index()
In [99]: list
Out[99]: [6, 5, 4, 3]
In [100]: list.index(6)
Out[100]: 0
In [101]: list.index(5)
Out[101]: 1
#Python列表的内置函数:
1. cmp(list,list2)：比较两个列表元素（等于返回0，大于返回1，小于返回-1）。
2. len(list)：计算列表元素个数。
3. max(list)：返回列表中元素最大值。
4. min(list)：返回列表中元素最小值。
7) 字典(无序)
: dict = {'A':'1','B':'2','C':'3'}
#字典的元素是以 key:value 的形式存储的，每个元素都必须有key和value哪怕是空，并且key值在元素中唯一。
#查找key值，若不存在可以返回指定的默认值
dict.get(key,“None”)
In [142]: dict.get('B',"None")
Out[142]: '2'
In [143]: dict.get('B')
Out[143]: '2'
In [144]: dict.get('b',"None")
Out[144]: 'None'
#判断key值，在字典里返回true，否则返回false
dict.has_key
In [148]: dict.has_key('B')
Out[148]: True
In [149]: dict.has_key('b')
Out[149]: False
#将字典打印为数组
dict.items()
In [150]: dict.items()
Out[150]: [('A', '1'), ('C', '3'), ('B', '2')]
#拷贝
dict.copy()
In [151]: d = dict.copy()
In [152]: d
Out[152]: {'A': '1', 'B': '2', 'C': '3'}
#清除
dict.clear()
In [153]: dict
Out[153]: {'A': '1', 'B': '2', 'C': '3'}
In [154]: dict.clear()
In [155]: dict
Out[155]: {}
#指定删除key，并显示values，若不存在则会显示指定的输出选项
dict.pop(key,"None")
In [160]: dict
Out[160]: {'A': '1', 'B': '2', 'C': '3'}
In [161]: dict.pop('b',"None")
Out[161]: 'None'
In [162]: dict.pop('B',"None")
Out[162]: '2'
In [163]: dict
Out[163]: {'A': '1', 'C': '3'}
#更新或将两个字典组合
dict.update()
In [169]: dict
Out[169]: {'A': '1', 'C': '3'}
In [170]: dict2
Out[170]: {'D': '4'}
In [171]: dict.update(dict2)
In [172]: dict
Out[172]: {'A': '1', 'C': '3', 'D': '4'}
#查看字典的所有 key
dict.keys()
In [173]: dict.keys()
Out[173]: ['A', 'C', 'D']
#查看字典的所有 values
dict.values()
In [174]: dict.values()
Out[174]: ['1', '3', '4']
#给字典添加元素
dict['key'] = value
In [176]: dict['F'] = '5'
In [177]: dict
Out[177]: {'A': '1', 'C': '3', 'D': '4', 'F': '5'}
#Python字典的内置函数:
1. cmp(dict,dict2)：比较两个字典元素（等于返回0，大于返回1，小于返回-1）。
2. len(dict)：计算字典元素个数。
3. str(dict): 将字典以字符串显示。
五、运算
算数运算：
+ : 加
- : 减
* : 乘
/ : 除
% : 取余
** : 幂
//: 取整
比较运算：
== : 等于
!= : 不等于
<> : 不等于
> : 大于
< : 小于
>= : 大于等于
<= : 小于等于
赋值运算：
= : a = b + c
+= : c += a 等于 c = c + a
-= : c -= a 等于 c = c - a
*= : c *= a 等于 c = c * a
/= : c /= a 等于 c = c / a
%= : c %= a 等于 c = c % a
**= : c **= a 等于 c = c ** a
//= : c //= a 等于 c = c // a
逻辑运算：
and
真真 真
真假 假
假假 假
or
真真 真
真假 真
假假 假
not
真 假
假 真
六、条件表达式
条件语句：
1) if..
if expression：
statement(s)
2) if...else
if expression：
statement(s)
else：
statement(s)
3) if...elif...else
if expression：
statement(s)
elif expression：
statement(s)
else：
statement(s)
循环语句：
1) for iterating_var in sequence:
statement(s)
2) for iterating_var in sequence:
statement(s)
else：
#当for循环正常结束时才会执行else
statement(s)
3) while True:
#死循环
statement(s)
4) while expression：
statement(s)
5) while expression：
statement(s)
else：
statement(s)
#正常结束循环才会打印else
print 自带换行符:
print i # 自动换行
print i, # 将换行符转换为空格
列表重写:
[i for i in range(10) if i % 2 == 0] [i**2 for i in range(10)]
xrange() 和 range()
xrange()是将列表转化为一个对象（常用）
range()是将列表保存到内存，列表过大会占用过多的内存
循环遍历字典：
for k in dict:
print "%s --> %s" % (k,dict[k])
for k,v in dict.items():
print k,v
for k,v in dict.iteritems():
print k,v
使用for循环遍历文件:
with open('/root/scripts/python/open.txt') as fd:
#将文件打开并转换为一个对象
for line in fd:
print line,
使用while循环遍历文件：
fd = open('/root/scripts/python/open.txt')
#将文件打开并将内容读入到内存
while True:
line = fd.readline()
if not line:
break
print line,
fd.close
#关闭文件
while 与 for 对比：
#for循环用在有次数的循环上 #while循环用在有条件的控制上 #while循环表达式必须返回一个True或False
七、扩展
1. python 的文件类型
python 有三种文件类型分别是 .py .pyc .pyo
.py 默认创建类型
.pyc 是经过编译形成的字节码，不能正常显示
.pyo 经过优化后的字节码
2. #!/usr/bin/env python 和 #!/usr/bin/python 的区别
若系统中存在多个python版本的情况下：
#!/usr/bin/env python (默认使用) : 根据系统的path环境变量决定使用那个版本，同时也方便与版本的变化。这样就只需要更改path变量中的python路径就可以了。 #!/usr/bin/python : 指定系统中的某一个版本的python运行，若需要切换其他版本时，就需要在脚本中更改。
3. ipython的安装方法：
ipython是linux上的python解释器并支持tab建补全
安装环境：
[root@test ~]# python -V
Python 2.6.6
[root@test ~]# cat /etc/issue
CentOS release 6.5 (Final)
Kernel \r on an \m
#替换本地yum源
cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
#生成缓存
yum clean all
yum makecache
#安装epel扩展
yum install epel-release-6-8.noarch -y
#安装 pip 常用于安装 python 模块
yum install python-pip -y
#pip查看已经安装的python模块
pip list
#使用pip安装ipython（这里的python版本为2.6.6 所以使用的ipython为1.2.1 若版本过高就会报错）
pip install ipython==1.2.1
#运行ipython
[root@test ~]# ipython
#无网环境安装，下载并上传ipython-1.2.1的tar.gz压缩包，解压并进入到目录中执行 setup.py install
浙公网安备 33010602011771号