Python学习笔记

对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10的9次方就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

如果字符串内部既包含'又包含",用转义字符\来标识,转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。Python还允许用r''表示’’内部的字符串默认不转义。

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

Python允许用'''...'''的格式表示多行内容。

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

一个布尔值只有True、False两种值，布尔值可以用and、or和not运算。注意大小写敏感。

空值是Python里一个特殊的值，用None表示。

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数。还有一种除法是//，称为地板除,只取结果的整数部分。

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

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

Python3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。还可以用十六进制写字符串。

>>> '\u4e2d\u6587'
'中文'

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

x = b'ABC'

Unicode表示的str通过encode()方法可以编码为指定的bytes。反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法。如果bytes中只有一小部分无效的字节，可以传入errors=’ignore’忽略错误的字节。

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'

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

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

当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

%运算符就是用来格式化字符串的。

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

格式化整数和浮点数还可以指定是否补0和整数与小数的位数。转义：用%%来表示一个%。

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

用len()函数可以获得list元素的个数。可以用索引来访问list中每一个位置的元素，索引是从0开始的。如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素。以此类推，可以获取倒数第2个、倒数第3个。append():往list中追加元素到末尾。pop():删除list末尾的元素,要删除指定位置的元素，用pop(i)方法，其中i是索引位置。insert(1, 'Jack'):把元素插入到指定的位置。把某个元素替换成别的元素，list[1] = 'Jack':可以直接赋值给对应的索引位置。list里面的元素的数据类型也可以不同。list元素也可以是另一个list，类似多维数组。

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

tuple和list非常类似，但是tuple一旦初始化就不能修改。只有1个元素的tuple定义时必须加一个逗号,,来消除歧义。Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

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

“可变的”tuple：tuple的每个元素，指向永远不变。即指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

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

条件判断语句的形式如下，注意:，elif是else if的缩写。

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数。int()函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。

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

Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

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

可使用for…in循环求和，注意冒号。

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

循环还有while。

sum = 0
n = 100
while n > 0:
    sum = sum + n
    n -= 1
print(sum)

break的作用是提前结束循环,也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。死循环时可以用Ctrl+C退出程序，或者强制结束Python进程。

用Python写一个dict如下（key-value存储方式），key不存在，dict就会报错。可以通过in或者dict提供的get()方法判断key是否存在。要删除一个key，用pop(key)方法，对应的value也会从dict中删除。dict是用空间来换取时间的一种方法，dict的key必须是不可变对象，因为内部使用哈希算法。 list是可变的，就不能作为key。

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
>>> 'Thomas' in d
False
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

set和dict类似，但在set中，没有重复的key。要创建一个set，需要提供一个list作为输入集合。通过add(key)方法可以添加元素，通过remove(key)方法删除元素。两个set可以做数学意义上的交集、并集等操作。

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

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。使用key-value存储结构的dict在Python中非常有用，选择不可变对象作为key很重要，最常用的key是字符串。

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。定义默认参数要牢记一点：默认参数必须指向不变对象！

def add_end(L=[]):
    L.append('END')
    return L

可变参数：定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

>>> calc(1, 2)
5
>>> calc()
0

如果已经有一个list或者tuple，要调用一个可变参数，Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去。

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，对kw的改动不会影响到函数外的extra。

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。比如定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)