python（1）-- 变量类型

常规：

Python有五个标准的数据类型：

Numbers（数字）：数字数据类型用于存储数值。他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。String（字符串）：由数字、字母、下划线组成的一串字符。eg: str="a1a2a3....an".它是编程语言中表示文本的数据类型。List（列表）：以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。加号（+）是列表连接运算符，星号（*）是重复操作。Tuple（元组）：用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。Dictionary（字典）：是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

强调：

(1) 在 python 中，类型属于对象，变量是没有类型的!!:

a=[,,]
a="Runoob"

以上代码中，[,,] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

（2）变量赋值简单粗暴不需要声明类型, 灵活多变,非常好用。

数字数据类是不可改变的数据类型，改变数字数据类型会分配一个新的对象。

字符串的操作有基本的功能不需要再自己进行拼接遍历的操作。

列表用 “[ ]” 标识类似 C 语言中的数组。

元组用 “( )” 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

字典用 “{ }” 标识。字典由索引 key 和它对应的值 value 组成。

（3）赋值

变量赋值

a =
b = "god"

字符串赋值

str = 'this is string 1'

列表串赋值

 list = []

元组赋值

 tuple = ()

字典赋值

dict = {1:'this', 2:'is', 3:'dictionary', 4:4}

（4）python 的所有数据类型都是类,可以通过 type() 查看该变量的数据类型:

>>> n="runoob"
>>> type(n)
<type 'str'>

此外还可以用 isinstance 来判断：

>>> a =
>>> isinstance(a, int)
True

isinstance 和 type 的区别在于：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是:

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

1. Number (数字)

作用： 用于存储数值

　 强调：（1）数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。

　(2) 您也可以使用 del 语句删除一些 Number 对象引用。

del语句的语法是：
  del var1[,var2[,var3[....,varN]]]]

　(3) Python 支持四种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
• 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。最好是用 L, 以免小与数字 “1” 混淆。
• = ）
• 复数( (complex numbers)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

（4）常用函数/常量（需要时查看即可）类型准换、数学函数、随机数函数、三角函数、数学常量

Python Number 类型转换
int(x [,base ])         将x转换为一个整数
long(x [,base ])        将x转换为一个长整数
float(x )               将x转换到一个浮点数
complex(real [,imag ])  创建一个复数
str(x )                 将对象 x 转换为字符串
repr(x )                将对象 x 转换为表达式字符串
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )               将序列 s 转换为一个元组
list(s )                将序列 s 转换为一个列表
chr(x )                 将一个整数转换为一个字符
unichr(x )              将一个整数转换为Unicode字符
ord(x )                 将一个字符转换为它的整数值
hex(x )                 将一个整数转换为一个十六进制字符串
oct(x )                 将一个整数转换为一个八进制字符串  

Python数学函数
函数    返回值 ( 描述 )
abs(x)    返回数字的绝对值，如abs(-) 返回
ceil(x)    返回数字的上入整数，如math.ceil(
cmp(x, y)    如果 x < y 返回 -, 如果 x == y 返回 , 如果 x > y 返回
exp(x)    返回e的x次幂(ex),如math.exp() 返回2.
fabs(x)    返回数字的绝对值，如math.fabs(-) 返回10.
floor(x)    返回数字的下舍整数，如math.floor(
log(x)    如math.log(math.e)返回1.,math.log(,)返回2.
log10(x)    返回以10为基数的x的对数，如math.log10()返回 2.0
max(x1, x2,...)    返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)    返回给定参数的最小值，参数可以为序列。
modf(x)    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)    x**y 运算后的值。
round(x [,n])    返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)    返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt()返回 +0j

Python随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
函数    描述
choice(seq)    从序列的元素中随机挑选一个元素，比如random.choice(range())，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])    从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()    随机生成下一个实数，它在[,)范围内。
seed([x])    改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)    将序列的所有元素随机排序
uniform(x, y)    随机生成下一个实数，它在[x,y]范围内。

Python三角函数
Python包括以下三角函数：
函数    描述
acos(x)    返回x的反余弦弧度值。
asin(x)    返回x的反正弦弧度值。
atan(x)    返回x的反正切弧度值。
atan2(y, x)    返回给定的 X 及 Y 坐标值的反正切值。
cos(x)    返回x的弧度的余弦值。
hypot(x, y)    返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)    返回的x弧度的正弦值。
tan(x)    返回x弧度的正切值。
degrees(x)    将弧度转换为角度,如degrees(math.pi/) ， 返回90.
radians(x)    将角度转换为弧度

Python数学常量
常量    描述
pi    数学常量 pi（圆周率，一般以π来表示）
e    数学常量 e，e即自然常数（自然常数）。

2. String(字符串)

创建：使用引号( ' or " )来创建字符串。创建字符串很简单，只要为变量分配一个值即可,eg: var1 = 'Hello World!'

　 强调：（1）Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。

(2) Python访问子字符串，可以使用方括号来截取字符串，如下实例：

#!/usr/bin/python

var1 = 'Hello World!'
var2 = "Python Runoob"

print ]
print :]

以上实例执行结果：
var1[]:  H
var2[:]:  ytho

(3) 你可以对已存在的字符串进行修改，并赋值给另一个变量.eg:

#!/usr/bin/python
# -*- coding: UTF- -*-

var1 = 'Hello World!'
print ] + 'Runoob!'

以上实例执行结果
更新字符串 :-  Hello Runoob!

（4）字符（需要时查看即可）

-- 转义字符

-- 字符串运算符

-- 字符串格式化：Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。eg:

#!/usr/bin/python

print ) 

以上实例输出结果：
My name  kg!

-- 三引号（triple quotes）：(1) 三引号可以将复杂的字符串进行复制；(2)三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符；（3）语法是一对连续的单引号或者双引号（通常都是成对的用）。eg1,2:

 >>> hi = '''hi
there'''
>>> hi   # repr()： 复制
'hi\nthere'
>>> print hi  # str()： 打印
hi
there  

-- Unicode 字符串：Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：

>>> u'Hello World !'   #引号前小写的"u"表示这里创建的是一个 Unicode 字符串。
u'Hello World !'  

如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：

>>> u'Hello\u0020World !'   #被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。
u'Hello World !'

--字符串内建函数：这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。

string.capitalize()：把字符串的第一个字符大写
string.center(width)：返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
, end=len(string))：返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')：以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
string.encode(encoding='UTF-8', errors='strict')：以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
, end=len(string))：检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
)：把字符串 。
, end=len(
, end=len(string)):跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum():如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha():如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal():如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit():如果 string 只包含数字则返回 True 否则返回 False.
string.islower():如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric():如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace():如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle():如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper():如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq):以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width):返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower():转换 string 中所有大写字符为小写.
string.lstrip():截掉 string 左边的空格
string.maketrans(intab, outtab]):maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str):返回字符串 str 中最大的字母。
min(str):返回字符串 str 中最小的字母。
 元 素 的 元 组(string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2,  num=string.count(str1)):把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
,end=len(string) ):类似于 find()函数，不过是从右边开始查找.
,end=len(string)):类似于 index()，不过是从右边开始.
string.rjust(width):返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str):类似于 partition()函数,不过是从右边开始查找.
string.rstrip():删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str)):以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
string.splitlines([keepends]):按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
,end=len(string)):检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj]):在 string 上执行 lstrip()和 rstrip()
string.swapcase():翻转 string 中的大小写
string.title():返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper():转换 string 中的小写字母为大写
string.zfill(width):返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal():isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

3. List(列表)

格式：以作为一个方括号内的逗号分隔值出现。

创建：（1）可直接创建，元素可以是不同的数据类型，eg：movies = ["The Holy Grail",1975,"The Life of Brain",1979]；

　  （2）可使用 python 的列表生成器 range()，形式有：

　a. range(n,m): 函数range返回一个整数列表，结果为[n,n+1,n+2,...,m)，相邻两数之间的差值为1.eg:

a = range(,)
print a     # result = [,,]

　b. range(n): 函数range返回一个整数列表，结果为[0,1,...,n).eg:

a=range(8)print a  # result = [0,1,2,3,4,5,6,7]

eg1：a = range(1,20,4)
         print a  # result = [1,5,9,13,17] 

eg2：b = [x*5 for x in range(2,10,2)]  ''' 5*x，x是2-10范围内，以2为步长的元素。那就是2 4 6 8，所以生成了[10， 20， 30， 40]'''
         print b   # result = [10, 20, 30, 40]

　　c. range(n,m,k): 函数range产生一个在数学上成为等差数列的列表。起始值为n，结束值为m，步长为k。eg:

a=range(8)print a  # result = [0,1,2,3,4,5,6,7]

eg1：a = range(1,20,4)
         print a  # result = [1,5,9,13,17] 

eg2：b = [x*5 for x in range(2,10,2)]  # 5*x，x是2-10范围内，以2为步长的元素。那就是2 4 6 8，所以生成了[10， 20， 30， 40]
         print b   # result = [10, 20, 30, 40]

　强调：（1）列表的数据项不需要具有相同的类型，只要把逗号分隔的不同的数据项使用方括号括起来即可。eg：list1 = ['physics', 1997, 2000];

　　    （2）序列都可以进行的操作包括索引（从 0 开始），切片（截取），加（组合），乘（重复），检查成员。

　　　　（3）Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

使用：（1）访问列表中的值：使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，eg：

#!/usr/bin/python

list1 = [, ];
list2 = [, , , , , ,  ];

print ]         # 访问第一个值
print :]     # 截取
print ]     #访问倒数第二个值

以上实例输出结果：
list1[]:  physics
list2[:]:  [, , , ]
List2[-]: 

（2）更新列表：可以对列表的数据项进行修改或更新（eg：list[2] = 2001;），你也可以使用append()方法来添加列表项。

（3）删除列表元素：使用 del 语句来删除列表的的元素（eg：del list[2];），你也可以使用remove()方法来删除列表项。

（4）列表脚本操作符：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。eg：

Python 表达式            结果                    描述
len([, , ])                                    长度
[, , ] + [, , ]        [, , , , , ]        组合
[                ['Hi!', 'Hi!', 'Hi!', 'Hi!']        重复
 , , ]            True                元素是否存在于列表中
, , ]: print x,                      迭代

（5）列表截取,eg: L[2]: 读取列表中第三个元素,   L[-2]: 读取列表中倒数第二个元素,   L[1:]: 从第二个元素开始截取列表

(6) 列表函数&方法：

cmp(list1, list2)：比较两个列表的元素
len(list)： 列表元素个数
max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：将元组转换为列表

list.append(obj)： 在列表末尾添加新的对象
list.count(obj)： 统计某个元素在列表中出现的次数
list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)：将对象插入列表
list.pop(obj=list[-])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)：移除列表中某个值的第一个匹配项
list.reverse()：反向列表中元素
list.sort([func])：对原列表进行排序

（7）python 创建二维列表

要求：将需要的参数写入 cols 和 rows 即可，格式：

list_2d = [[ for col in range(cols)] for row in range(rows)]

实例：

实例：
>>> list_2d = [ [ )] )]
>>> list_2d[].append()
>>> list_2d[].append()
>>> list_2d[].append()
>>> list_2d
[[, , , , , , ], [, , , , ], [, , , , , ], [, , , , ], [, , , , ]]

4. Tuple(元组)

格式：只需要在小括号中添加元素，并使用逗号隔开即可。

　强调：（1）元组的元素不能修改，但我们可以对元组进行连接组合.

（2）元组中只包含一个元素时，需要在元素后面添加逗号。eg：tup1 = (50,);

　　　    (3) 元组与字符串类似，下标索引从0开始，可以进行截取([:])，组合（+），复制（*）等。

（4）任意无符号的对象，以逗号隔开，默认为元组，eg：>>print 'abc', -4.24e93, 18+6.6j, 'xyz';   ...>>abc -4.24e+93 (18+6.6j) xyz

使用：（1）访问元组：可以使用下标索引来访问元组中的值，eg:

#!/usr/bin/python

tup1 = (, );
tup2 = (, , , , , ,  );

print ]
print :]

以上实例输出结果：
tup1[]:  physics
tup2[:]:  (, , , )

(2) 修改元组：元组中的元素是不允许修改的，但我们可以连接组合元组： 使用加号连接两个元组，eg：

#!/usr/bin/python
# -*- coding: UTF- -*-

tup1 = (, 34.56);
tup2 = ('abc', 'xyz');

# 以下修改元组元素操作是非法的。
# tup1[] = ;

# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;

以上实例输出结果：
(, 34.56, 'abc', 'xyz')

（3）删除元组：元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组，eg：

#!/usr/bin/python

tup = (, );

print tup;
del tup;
print "After deleting tup : "
print tup;

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
(, )
After deleting tup :
Traceback (most recent call last):
  File , in <module>
    print tup;
NameError: name 'tup' is not defined

（4）元组运算符（同列表）：与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合(+)和复制(*)，运算后会生成一个新的元组。

(5) 元组索引/截取 (同列标), eg: L[2]: 读取列表中第三个元素,   L[-2]: 读取列表中倒数第二个元素,   L[1:]: 从第二个元素开始截取列表

(6) 元组内置函数：

cmp(tuple1, tuple2)：比较两个元组元素。
len(tuple)：计算元组元素个数。
max(tuple)：返回元组中元素最大值。
min(tuple)：返回元组中元素最小值。
tuple(seq)：将列表转换为元组。

5. Dictionary(字典)

格式：字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2[,  .... ]}

　强调：（1）字典是另一种可变容器模型，且可存储任意类型对象。

　　　　 (2) 键必须是唯一的，但值则不必。

(3) 值可以取任何数据类型，既可以是标准的对象，也可以是用户定义的 , 但键必须是不可变的，如字符串，数字或元组。eg: dict2 = { 'abc': 123, 98.6: 37 };

使用：（1）访问字典里的值：把相应的键放入熟悉的方括弧，eg:

#!/usr/bin/python

dict = {, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];

以上实例输出结果：
dict['Name']:  Zara
dict[

如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python

dict = {, 'Class': 'First'};
print "dict['Alice']: ", dict['Alice'];

以上实例输出结果：
dict['Alice']:
Traceback (most recent call last):
  File , in <module>
    print "dict['Alice']: ", dict['Alice'];
KeyError: 'Alice'

（2）修改字典：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。

#!/usr/bin/python

dict = {, 'Class': 'First'};

dict[; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School']; 

以上实例输出结果：
dict[
dict['School']:  DPS School

（3）删除字典元素：能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用 del 命令，eg:

#!/usr/bin/python
# -*- coding: UTF- -*-

dict = {, 'Class': 'First'};

del dict['Name']; # 删除键是'Name'的条目
dict.clear();     # 清空词典所有条目
del dict ;        # 删除词典

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];

但这会引发一个异常，因为用del后字典不再存在：
dict['Age']:
Traceback (most recent call last):
  File , in <module>
    print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

(4) 字典键的特性：

--- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，eg：

#!/usr/bin/python

dict = {, 'Name': 'Manni'};

print "dict['Name']: ", dict['Name'];

以上实例输出结果：
dict['Name']:  Manni

--- 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，eg：

#!/usr/bin/python

dict = {[};

print "dict['Name']: ", dict['Name'];

以上实例输出结果：
Traceback (most recent call last):
  File , in <module>
    dict = {[};
TypeError: list objects are unhashable

(6) 字典内置函数：

cmp(dict1, dict2)：比较两个字典元素。
len(dict)：计算字典元素个数，即键的总数。
str(dict)：输出字典可打印的字符串表示。
type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。

dict.clear()：删除字典内所有元素
dict.copy()：返回一个字典的浅复制
dict.fromkeys(seq[, val]))：创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)：如果键在字典dict里返回true，否则返回false
dict.items()：以列表返回可遍历的(键, 值) 元组数组
dict.keys()：以列表返回一个字典所有的键
dict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)：把字典dict2的键/值对更新到dict里
dict.values()：以列表返回字典中的所有值