Python基础-数据类型和基础语法

数据类型

现代计算机能处理很多各种各样的数据，不同的数据就需要定义不同的数据类型，python中能够直接处理的数据类型有以下几种：

整数

可以是任意大小的整数，整数的运算永远是精确的，包括除法

浮点数

浮点数的运算可能有四舍五入的误差

字符串

是使用”或者”“括起来的任意文本例如’hello’, “world”。但是需要注意的是”或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”“括起来，比如”I’m OK”包含的字符是I，’，m，空格，O，K这6个字符。

关于转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。我们可以测试一下

>>> print('I\'m fine')
>>> print('I\'m learning \n Python')
I'm fine
I'm learning
Python

其中python可以使用r”表示”内部的字符串不进行转义，例如上面的代码：

>>> print(r'I\'m fine')
>>> print(r'I\'m learning \n Python')
I\'m fine
I\'m learning \n Python

布尔值

python使用True和False来表示布尔值，布尔值可以使用and、or、not运算分别是与、或、非，例如for循环、if语句等等都可以使用。

空值

在python中使用None表示它很特殊，不能理解为0，因为0是整数是有意义的。

除了上面的python还提供了列表、字典等多种数据类型我们在接下来讨论。

变量

python使用的是动态语言，与之相对的是静态语言，例如C++、Java。静态语言在定义变量是必须指定类型，例如：

int value = 5;
value = "hehe" //这样是错误的

所以，动态语言更加灵活。

我们还需要理解计算机内存中是怎么处理变量的。

例如： val = ‘ABC’

python解释器进行了以下处理：

1. 在内存中创建了一个字符串’ABC’

2. 在内存中创建了一个名为val的变量，并指向’ABC’

常量

一般使用全大写表示

PI = 3.14159265…

但是python其实并不能保证PI不会改变，所以这只是一个约定。

最后解释一下整数的除法为什么也是精确的。在Python中，有两种除法，一种除法是’/’：

>>> 10 / 3
3.3333333333333335

‘/’除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 9 / 3
3.0

还有一种除法是’//’，称为地板除，两个整数的除法仍然是整数：

>>> 10 // 3
3

你没有看错，整数的地板除’//’永远是整数，即使除不尽。要做精确的除法，使用’/’就可以。

因为’//’除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 10 % 3
1

无论整数做’//’除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

容器

[b]list[/b]

list是python内置的数据类型，可以任意添加、删除操作。

例如：

>>> names = ['Bob', 'Tom', 'Jk']

#获取某个、全部元素、以及list长度
>>> print(names)
['Bob', 'Tom', 'Jk']
>>> print(names[0], names[2])
Bob Jk
>>> print(len(names))
3
>>> print(names[-1], names[-2])
Jk Tom

增加和删除某一元素

#增加元素
>>> names.append('Michael')
>>> print(names)
['Bob', 'Tom', 'Jk', 'Michael']

>>> names.insert(1, 'Jack')
>>> print(names)
['Bob', 'Jack', 'Tom', 'Jk', 'Michael']

#删除元素
>>> names.pop()
>>> print(names)
['Bob', 'Jack', 'Tom', 'Jk']
>>> print(names.pop(1))
Jack
>>> print(names)
['Bob', 'Tom', 'Jk']

list中还可以存放不同类似的数据：

>>> lists = ['ABC', 123, 4.5,['a', True], None]
>>> print(lists)
>>> print(len(lists))
['ABC', 123, 4.5, ['a', True], None]
5

[b]tuple[/b]

它和list类似，但是tuple一旦初始化之后不可以修改！

tuple的使用以及注意事项如下：

>>> tup = ('hi', 321)
>>> print(tup, len(tup), type(tup))
('hi', 321) 2 <class 'tuple'>

>>> tup = ()
>>> print(tup, len(tup), type(tup))
() 0 <class 'tuple'>

#注意接下来两个的区别
>>> tup = ('A')
>>> print(tup, len(tup), type(tup))
A 1 <class 'tuple'>

#得到了一个错误
>>> tup = (9)
>>> print(tup, len(tup), type(tup))
TypeError: object of type 'int' has no len()

看错误提示为什么tup变成了一个int？这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是9。

所以，只有1个元素(字符串最好也遵守这个规则)的tuple定义时必须加一个逗号，来消除歧义：

>>> tup = (9,)
>>> print(tup, len(tup), type(tup))
(9,) 1 <class 'tuple'>

虽然说tuple不可修改，但是假如一个tuple包含了一个list会怎么样呢？

>>> tup = ('Str', 123, ['list', 321])
>>> print(tup[2][1])
321

>>> tup[2][1] = True
>>> print(tup[2][1])
True

>>> tup[1] = 555
TypeError: 'tuple' object does not support item assignment

tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

[b]dict[/b]

python中称为字典，在其它语言也称为map，使用键值对(key-value)存储数据，查找极快。

举例一个同学对应一个分数，我们就可以使用dict实现。

>>> d = {'Bob':89, 'Jack':30}
>>> print(d)
{'Bob': 89, 'Jack': 30}

或者修改一个同学的分数(没有会自动创建，相同会替换原来的数字)

>>> d['Lis'] = 59
>>> d['Bob'] = 100
>>> print(d)
{'Bob': 100, 'Jack': 30, 'Lis': 59}

但是打印例如d[‘Tom’]这样不存在的key就会报错，所有我们最好判断一下：

if 'Tom' in d:
print(d['Tom'])
else:
d['Tom'] = 66
print(d['Tom'])

或者使用get方法：

>>> print(d.get('Ben'))
>>> print(d.get('Ben'), -1)
None
None -1

-1是自己设置的错误码。

删除一个key则可以使用pop(key)方法进行：

>>> print(d)
>>> d.pop('Bob')
>>> print(d)
{'Bob': 100, 'Jack': 30, 'Lis': 59, 'Tom': 66}
{'Jack': 30, 'Lis': 59, 'Tom': 66}

同样如果不存在会报错。

还有一点请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；

2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；

2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

创建一个set需要一个list。

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

注意两点：一是重复key不会出现，二是set输出顺序不代表数据存储顺序！

可以使用add()方法添加元素，remove删除元素，

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

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

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

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

不可变对象

在基本数据类型中，例如：str是不变对象，list是可变对象，例如：

>>> lists = ['a', 'c', 'b']
>>> lists.sort()
# sorted(lists) 该函数返回一个list对象，为排序后的，不影响原来的list
>>> print(lists)
['a', 'b', 'c']

但是str类型的数据

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

可以看到a没有变还是’abc’，b才是’Abc’。

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

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

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

基础语法

条件判断

这个大家应该都能理解，举个例子说明一下：

score = 100

if score >= 90:
print('best')
else:
print('general')
>best

或者更加复杂一点的判断：

if score >= 90:
print('best')
elif score >= 60:
print('good')
else:
print('general')

其中elif是 else if的缩写

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

循环

[b]for[/b]

例如我们想要计算1+2+….+100。直接写当然也可以，但是有循环的方法为什么不用呢。

简单的循环就先不看了，看一个稍微复杂一点的：

lists = ['String', 123, True, None]
for elem in lists:
print(elem)
>String
>123
>True
>None

所以for xxx in xxxs循环就是把xxxs每个元素放入元素xxx中，然后执行代码。

例如我们想要计算1-5的和：

sum = 0
for x in [1,2,3,4,5]:
sum += x
print(sum)

但是怎么计算1-100呢，直接写也太长了。

我们可以使用range()方法：

for x in range(101):
sum += x
print(sum)

打印出结果5050，其中range(101)是生成了从0-100的整数序列。

[b]while[/b]

还有一种循环是while，简单写一下

i = 10
i_list = []
while i > 5:
i -= 1
i_list.append(i)
print(i_list)
#结果为[9,8,7,6,5]

[b]break[/b]

break就是结束当前循环。

i = 10
i_list = []
while i > 5:
if i < 8:
break
i -= 1
i_list.append(i)
print(i_list)
#结果为[9, 8, 7]

[b]continue[/b]

==和C++、Java等语言一样。。。