1、基本数据类型和变量

1.1、基本类型

整数：正数、负数、0。如1，0，-1。进制表示0x表16进制。

浮点数：数学写法。1.23， -9.01。科学计数法，把10用e表示。1.2e2=120，1.2e-1=0.12。

布尔型：True，False两种值。可以用and、or和not运算。

1.2、强制装换

数据类型转换函数是Python内置的常用函数，比如int()函数可以把其他数据类型转换为整数等等。

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> bool(1)
True
>>> bool('')
False
>>> hex(18)
'0x12'

注：不能直接将float型字符串转为int。如int('12.34')会报错，实际调用应为int（float('12.34')）

1.3、常量/变量

1、常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

2、理解变量

当我们写：a = 'ABC'时，Python解释器干了两件事情：

1）在内存中创建了一个'ABC'的字符串；

2）在内存中创建了一个名为a的变量，并把它指向'ABC'。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = 'ABC'
b = a
a = 'XYZ'
print(b) # 'XYZ' 

最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？如果从数学意义上理解，就会错误地得出b和a相同，也应该是'XYZ'，但实际上b的值是'ABC'，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = 'ABC'，解释器创建了字符串'ABC'和变量a，并把a指向'ABC'：

执行b = a，解释器创建了变量b，并把b指向a指向的字符串'ABC'：

执行a = 'XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，但b并没有更改：

所以，最后打印变量b的结果自然是'ABC'了。

if x:只要x是, x非零数值、非空字符串、非空list等，就判断为True，否则为False。

2、list

list是一种有序的集合，可以随时添加和删除其中的元素，python里面list元素可以是不同数据类型的。

2.1、索引

从0开始，越界后报错；支持反向索引，-1为最后一元素，-len为第一个元素。

classmates[-2] => 'Bob';
classmates[0] => 'Michael';
classmates[3] => Traceback (most recent call last):File "<stdin>", line 1, in <module> IndexError: list index out of range;

2.2、尾追加元素append

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

2.3、插入元素到指定位置insert

>>> classmates.insert(1, 'Jack')  # 插入到索引为1的位置，原元素后移。
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

2.4、弹出制定位置元素pop

>>> classmates.pop()  # 弹出最后一元素。
'Adam'
>>> classmates.pop(1)  # 弹出索引为1的元素。
'Jack'

2.5、list元素数据类型可以不一样

>>>  L = ['Apple', 123, True]
或 >>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']

2.6、list元素扩展

a = [1]
print(a*5) => [1, 1, 1, 1, 1]

3、tuple

另一种有序列表叫元组：tuple。tuple一旦初始化就不能修改，所以在定义的时候，tuple的元素就必须被确定下来。它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

3.1、初始化

>>> classmates = ('Michael', 'Bob', 'Tracy')
>>> classmates
('Michael', 'Bob', 'Tracy')

定义空tuple， t = ()

定义一个元素的tuple， t = (1,) # 一个元素时，必须加","以消除歧义。

3.2、一个"可变的"tuple"

list的指针不能变，list本身的内容是可变的。

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

4、dict

dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。dict内部存放的顺序和key放入的顺序是没有关系的。

4.1、初始化

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

key不存在，dict就会报错。

4.2、判断key是否存在(key in dict)

>>> 'Thomas' in d  # False
>>> d.get('Thomas')  # none
>>> d.get('Thomas', -1)  # -1  #指定不存在时，返回的值

4.3、字典安全访问-get

通过get方法安全访问，有则给出value值，无则使用默认值，格式：dict.get(key, default)。

a = {"a":1, "b": 2}
print(a.get("a", None)) # 1
print(a.get("a", 1)) # 1
print(a.get("c", None)) # None
print(a.get("c", 1)) # 1

4.4、删除key => pop

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

或：

del d["Bob"]

4.5、key可以为Bool型，使用时会自动转换，也可以为数字

a = {True: 1, False: 2}
print(a[True]) # 1
print(a[False]) # 2
print(a[1]) # 1
print(a[0]) # 2

5、set

重复元素在set中自动被过滤，要创建一个set，需要提供一个list作为输入集合。显示的顺序也不表示set是有序的。

5.1、初始化

>>> s = set([1,1,1, 2, 3,3])
>>> s
{1, 2, 3}

5.2、添加元素add

>>> s.add(4)
>>> s
{1, 2, 3, 4}

5.3、删除元素remove

>>> s.remove(4)
>>> s
{1, 2, 3}

5.4、相交or合并

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

6、再议不可变对象

上面我们讲了，str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作,str内部的内容是不变的，如：

>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？

我们先把代码改成下面这样：

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。