python_基础_1

* 机器上装的是2.7.9版本。书上用的也是2.0版为基础写的

第二章 基本数据类型与变量

体系结构：

• 数据类型： 整型，浮点，复数，字串（普通，raw,转义字符）。 #这里应该是最基本的，而列表、字典、元组也是某种数据类型，在python中所有都是对象。
• 语法： 关键字，变量， 值
• 数据类型转换：自动转换，强制类型转换
• 运算符：算术运算符，比较运算符，位运算符，逻辑运算符

-----------------------------------------------------------------------

不同进制：

16位：‘0x’ or ‘0X‘前缀。8位： ‘0o’(第一个是零，第二个是欧)前缀。2位: ‘0b‘

例： >>>a = 0xff, b = 0o7

浮点运算，只要在数据后，加上小数点。就会自动转换

基本运算与其它差不多，有区别的：

幂运算: **

例： >>>print 2**3　　　　#2的3次方

　　8　

增加的除法：//　　　　#将舍去余数部分

>>> print 11.0//4.0

2.0

优先级：小括号>幂运算>乘,除,取模>加，减

位运算： &:按位与 |:按位或 ^:按位异或  ~:取反 <<:左移 >>:右移

基本与C类似

复数：平时应用不多，表达形式： real + imagj

内建属性： n.real:返回复数的实部， n.imag：返回复数的虚部, n.conjugate(): 返回共轭复数， 例：

 >>>n = 2+6j

 　　>>>print n

　　(2+6j)

　　>>>print n.real

　　2.0

　　>>>print n.imag

　　6.0

　　>>>print n.conjugate()　　#n的共轭复数

　　(2-6j)

字符串：用单引号或双引号括出，如：>>>s = "Hello, world."

转义符与C类同, 常用的有‘\n‘, ‘\t‘, ‘\‘, 其中‘\‘放在行尾时，相当于续行符

raw字串，如: r"c:\...\...", 省去了转义

输入多行时，可以用三个单引号，或双引号。例：

>>>print ‘‘‘this

...is

...test‘‘‘

this

is

test

>>>

Unicode字串: u"..."

2.5 类型转换

int(n[,base]):  将n转换成一个整数, base为待转换的进制数，缺省为十进制, 例：

>>> int(‘ff‘, 16)

255

>>>int(‘77‘, 8)

63

#注意，n要加引号，是个字串，后面的base进制是指这个串的，而非要转换成的值的进制

long(n[, base]): 将n转换蛋白尿一个长整数，其它同上

float(n): 将n转换成浮点数，默认保留一位小数

str(n): 将n转换成字串

list(s): 将s转成一个列表

tuple(s): 将s转成一个元组

unichr(n): 转成一个unicode字符

chr(n): n转成一个字符

ord(x): x转成对应的整数值。 注意，x是字符，而不是串，要用引号，另外，它是把这个字符的ascii码，转成数值。例:

>>>print ord(‘a‘)

97

hex(n): 将一个整数n转为对应的十六进制的字串。例：

>>> hex(255)

‘0xff‘

oct(n): 将n转成对应的八进制的字串，其它同上

bin(n): 将整数n转成对应的二进制字串。例：

>>>bin(255)

‘0b11111111‘

2.6 变量

关键字：

2.7 赋值语句

连续赋值： >>>x = y = z = 4

类似C的赋值， 增量赋值（后面会说明它对可变对象的不同）：

a += b, 　　a -= b, 　　a *= b, 　　a /=b, 　　a %=b, 　　a **=b, 　　a <<= b, 　　a >>= b

2.7.1变量的引用：

一切皆对象: 整数，浮点，字串等，都是作为对象存在的。每个对象有两个标准的头部信息：一个是标识这个对象的类型的类型标识符；另一个是记录引用次数的计数器。因此，python中变量是没有类型的，类型的概念是属于对象的。

变量的赋值与引用中要注意的是，变量有些像C中的指针，它是指向所引用的对象的地址。当自己的值变化后，它自身的地址也变了。

id(x): 返回对象的地址，例:

>>>id(10)　　　　#之前没有10，首先会创建10这个对象

30909804　　　　#对象10的地址

>>> x = 10　　　　#首先创建x变量， 然后将对象10与变量联系起来，即引用。引用就是将对象与变量绑定起来。变量像指针。指向了对象的内存空间

>>> id(x)　　　　#对象x的地址

3099804　　　　#x引用了10, 与10的地址相同

>>> x /= 2　　#x = 5，x相当于引用了新的对象

>>> id(x)　　　　#x的地址变了。

30909864　　　　#指向了新地址

>>>id(5)　　　　#对象5的地址

30909864　　　　#与x相同，说明x引用了它

注意与C中的不同:

>>> x = 1

>>> y = x

>>> x

1

>>> y

1

>>> x = 2.2

>>> x

2.2

>>> y

1

#当x重新赋值后，x指向了新地址，还是指向原来的1，并没有指向x的新引用，这在编程中要注意了。

2.7.2 赋值

通过上面知道，赋值是使变量建立对象的引用值，而非复制。赋值，不复……

整型，浮点型，字串是不可变的。当变量引用这些对象后，重新赋值，是创建一个新对象，而不是改变原来的对象，

但列表是可变的。例：

>>> R=[2, 4, 6, 8]

>>> S = R

>>> R

[2, 4, 6, 8]

>>> S

[2, 4, 6, 8]

>>> id(R)

35279176

>>> id(S)

35279176　　　　　　　　#两个变量指向相同的地址

>>> R[2] = 5　　　　　　#列表R的第三项变了。

>>>R

[2, 4, 5, 8]

>>> S　　　　　　　　　　#S也变了， 说明它的指向与R相同。也就是它们引用的列表[2, 4, 5, 8]的地址没变(其实是第三项指向的地址变了)。

[2, 4, 5, 8]

普通赋值与增量赋值的区别：

从上面了解，列表对象是可变的，而整型，浮点，字串是不可变的。两种赋值方式对不可变对象是一样的。都会创新一个新对象。而对可变对象却是不同的。

增量赋值会将可变对象就地修改，而不是创建新的对象， 例：

>>> L = [1,2,3]

>>> id(L)

35321096　　　　　　　　#列表地址

>>> L = L+[4]　　　　　　#普通赋值方式，创建了新的对象　　　　　

>>> id(L)　　　　　　　　

35319896　　　　　　　　#地址变了

>>> L += [5]　　　　　　#增量赋值，就地修改

>>> id(L)

35319896　　　　　　　　#地址没变

2.7.3 多重赋值

>>> x = y = z = 22

>>> x

22

>>> y

22

>>> z

22

------------------

>>> x, y, z = 2, ‘python‘, 3.56　　　　#注意，等号左边的变量数与右边的对象数必须一致，否则出错

>>> x

2

>>> y

‘python‘

>>> z

3.56

 (end)

python_基础_1

原文：http://www.cnblogs.com/cnyxj/p/6373843.html