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)元组运算符(同列表):与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合(+)和复制(*),运算后会生成一个新的元组。

python(1)-- 变量类型

(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():以列表返回字典中的所有值
上一篇:将double或则float类型保留小数


下一篇:float类型进行计算精度丢失的问题