Python学习笔记（一）基础

Python基础

Python使用缩进来组织代码块，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。

在文本编辑器中，需要设置把Tab自动转换为4个空格，确保不混用Tab和空格。

整数

浮点数

整数和浮点数在计算机内部的存储方式是不同的，整数运算永远是精确的（除法也是），而浮点数运算则可能会有四舍五入的误差。

字符串

字符串是以单引号'或双引号“括起来的任意文本。如果'本身也是一个字符那就可以用“”括起来，如“I'm OK”。

如果字符串既包含'又包含“，可以用转义字符\来标识：

'I\'m \"OK\"!'

表示的字符串内容为 I'm "OK"!

转义字符可以转义很多字符，如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义

>>> print('\\\t\\')
\       \
>>> print(r'\\\t\\')
\\\t\\

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容。

>>> print('''line1
... line2
... line3''')
line1
line2
line3

如果写成程序并存为.py文件，就是：

print('''line1
line2
line3''')

多行字符串'''...'''还可以在前面加上r使用，即多行字符串不转义。

布尔值

一个布尔值只有True和False两种，布尔值可以用and（&）、or（|）和not运算。

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True

>>> not True
False
>>> not False
True
>>> not 1 > 2
True

空值

Python的空值用None表示。

变量

在Python中，=是赋值语句，可以把任何数据类型赋给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，例如：

a=123 #a是整数
print(a)
a='ABC' #a是字符串
print(a)

这种变量本身类型不固定的语言叫做动态语言，即不需要声明标量类型。

理解变量在计算机内存中的表示：

a=‘ABC’

Python解释器干了两件事：

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

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

同样可以把变量a赋值给变量b：

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

可以得到结果'ABC'。

常量

在Python中有两种除法，一种除法是/：

>>>10/3
3.3333333333333335

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

>>>9/3
3.0

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

>>>10/3
3

//除法只取结果的整数部分，相当于C语言/除法。

Python提供余数运算：（%）

>>>10%3
1

故无论是//还是%，结果永远是整数，也就是前文所述整数运算永远是精确的。

注意：Python的整数没有大小限制。浮点数也没有大小限制，但是超出一定的范围就直接表示为inf（无限大）。

字符编码

UTF-8编码把一个Unicode（通常是2字节）字符根据不同的数字大小编码成1-6个字节，常用的英文字符被编码成1字节，汉字通常是3个字节，只有很生僻的字符才会编码成4-6个字节。如果要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

字符	ASCII	Unicode	UTF-8
A	01000001	00000000 01000001	01000001
中	x	01001110 00101101	11100100 10111000 10101101

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输时，就转换为UTF-8编码。

即当编辑文本时，UTF-8字符转换为Unicode字符到内存，编辑完成后，保存或传输时，再把Unicode转换为UTF-8进行保存或者传输。

Python的字符串

对于单个字符的编码，Python提供了ord()函数把字符转换为字符的编码数，chr()函数把编码转换为对应的字符：

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x=b'ABC'

要注意区分'ABC'和b'ABC'，前者是str，Unicode编码，后者虽然内容显示一致，但每个字符都只占用一个字节。

以Unicode表示的str通过encode（）方法可以编码为指定的bytes，例如：（' '.encode(' ')）

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
>>> x='ABC'
>>> x.encode('utf-8')
b'ABC'

注意：含有中文的str无法用ASCII编码。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode（）方法：（' '.decode(' ')）

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

len()函数

要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')
3
>>> len('中文')
2

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6

在操作字符串时，，经常遇到str和bytes的互相转换，为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

由于Python源代码也是一个文本文件，所以当源代码中包含中文字符时，在保存源代码时就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按照UTF-8读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

(如果源代码中含有中文：

1.确保文本编辑器使用UTF-8 without BOM；

2.源代码开头写上2行注释。)

格式化

在Python中，采用格式化的方式和C语言一致，用%实现，例如：

>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

有几个%？占位符，后面就跟几个变量或者值，顺序一一对应。如果只有一个%？，括号可以省略。

常见的占位符：

%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

>>> print('%2d-%02d' % (3, 1))
3-01
>>> print('%.2f' % 3.1415926)
3.14

如果不确定用什么，%s永远起作用，它会把任何类型转换为字符串：

>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'

当字符串里的%是一个普通字符时，这是用%%转义来表示一个%：

>>> 'growth rate: %d %%' % 7
'growth rate: 7 %'

list 和 tuple

list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。（list=[ ， ，]）

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。

用len()函数可以获取list元素的个数：

>>> len(classmates)
3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

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

注意：确保索引不越界。

如果要取最后一个元素，出了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>> classmates[-1]
'Tracy'

以此类推，可以获取倒数第二个、第三个：

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

同样不能越界。

list函数

除len()函数获取list元素个数外，还有以下函数：

.append( )可以往list中追加元素至末尾：

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

.insert(n, )可以把元素插入到指定的第n个位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

.pop()删除list末尾的元素：

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

.pop(i)删除指定位置的元素：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

把某个元素替换成别的元素，可以直接赋值给队友的索引位置：

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里的元素的数据类型也可以不同：

>>> L = ['Apple', 123, True]

list元素也可以是另一个list：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

要注意s只有4个元素，其中s[2]又是一个list。

要拿到'php'可以写s[2][1]，因此s可以看成是一个二维数组。累死的还有三维、四维……

如果list中一个元素也没有，就是一个空的list，长度为0。

tuple

另一种有序列表叫元组：tuple。（tuple=( , , )）。tuple一旦初始化就不能修改：

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

现在classmates这个tuple不能变了，也没有append(),insert()这样的方法。其他获取元素的方法和list一样，可以正常使用classmates[0],classmates[-1]，但不能复制成另外的元素。因为tuple不可变，所以代码不可变。

tuple陷阱：当定义一个tuple时，在定义的时候，tuple就必须被确定下来，如：

>>> t = (1, 2)
>>> t
(1, 2)

要定义一个空的tuple，可以写成（）：

>>> t = ()
>>> t
()

但是，定义一个只有一个元素的tuple时，必须要加一个逗号，来消除歧义（因为当t=(1)时，定义的不是tuple，而是1这个数）：

>>> t = (1,)
>>> t
(1,)

Python在显示只有一个元素的tuple时，也会加一个逗号。

“可变的”tuple：

当tuple内涵list类元素时，list内元素可变：

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

这是因为，变的是list内元素，而tuple指向的list并没有变成其他的list。所谓的“不变”是说，tuple每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list就不能改成指向其他对象，但指向的这个list本身是可以变的。（list内可变，指向的list不可变）

条件判断

基本语句：

if 条件 :
    执行语句
elif 条件 :
    执行语句
else :
    执行语句

elif是else if的缩写。注意不要少写了冒号。例如：

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

input()

有下面程序：

birth = input('birth: ')
if birth < 2000:
    print('00前')
else:
    print('00后')

输入1982，结果报错。

这是因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。int()函数完成了这件事：

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

再次运行，得到正确结果。但是如果输入abc，又会错误，，因为int()函数发现一个字符串不是合法数字时就会报错。

同样float()将整数和字符串转换为浮点数。

循环

Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

range(n)函数可以生成一个整数序列，再通过list函数就可以生成list。整数范围为0~n-1。

>>> list(range(5))
[0, 1, 2, 3, 4]

利用range，可以计算1~100的和：

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

range还可以指定起始数值：

>>>for num in range(2,6):
           print(num)
2
3
4
5

另外，range可以指定步长，在第三个数值标明步长：

>>>for num in range(2,10,2)
           print(num)
2
4
6
8

即在2~9范围内每次加2。

第二种循环是while循环，只要条件满足就一直循环，条件不满足时退出。

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

dict和set

dict

dict是python里的dictionary，即是字典的意思，可以存放key和对应的value，便于搜索。

初始化dict：

>>>d={'a':95,'b':85,'c':5}
>>>d['a']
95

还可以直接添加：

>>>d['d']=75
>>>d['d']
75

可以直接修改key对应的value：

>>>d['a']=55
>>>d['a']
55

如果key不存在，程序就会报错，要确定key存在不存在，有两种方法：

第一种是通过in：

>>>'e' in d
False

第二种是get（）函数，如果key不存在返回None，或者自己指定的数值：

>>>d.get('e')
>>>d.get('e',0)
0

要删除一个key，可以用pop（key），对应的value也会被删除：

>>>d.pop('a')
95
>>>d
{'b':85,'c':5,'d'75}

注意：dict的key必须是不可变的，在Python中，字符串、数字都是不可变的，而list可变，所以list不可以作为dict的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，所以set里的key值也必须是唯一的。

要创建一个set，需要提供一个list作为输入集合：

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

注意，传入的[1,2,3]是一个list，而显示的{1,2,3}则表明set里有1,2,3这三个元素。
重复元素在set中被自动过滤：

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

可以使用add（key）向set中添加元素：

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

使用remove（key）移除元素：

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

set可以看成是数学上无序和无重复元素的集合，因此可以使用交集、并集等操作（&、|）

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